HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1074:22571433397b

Refactor graphical side of pie to simplify the implementation.

Jani Honkonen -

r1074:22571433397b

parent child

Context file:

r1074:22571433397b

Collapse all files

src/animations/chartanimator.cpp +3 -10

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartanimator_p.h"
             #include "axisanimation_p.h"
             #include "xyanimation_p.h"
             #include "splineanimation_p.h"
             #include "xychartitem_p.h"
             #include "pieanimation_p.h"
             #include "baranimation_p.h"
             #include "barchartitem_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>)
             Q_DECLARE_METATYPE(QVector<QRectF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             const static int duration = 1000;
             ChartAnimator::ChartAnimator(QObject *parent):QObject(parent),
                 m_state(ShowState)
             {
             }
             ChartAnimator::~ChartAnimator()
             {
             }
             void ChartAnimator::addAnimation(ChartAxis *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::addAnimation(BarChartItem *item)
             {
                 ChartAnimation *animation = m_animations.value(item);
                 if (!animation) {
                     animation = new BarAnimation(item);
                     m_animations.insert(item, animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::removeAnimation(Chart *item)
             {
                 item->setAnimator(0);
                 m_animations.remove(item);
             }
             void ChartAnimator::updateLayout(ChartAxis *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() == ChartAxis::X_AXIS ? rect.left() : rect.bottom();
                         oldLayout[j] = item->axisType() == ChartAxis::X_AXIS ? rect.right() : rect.top();
                     }
                 }
                     break;
                 case ZoomInState: {
                     int index = qMin(oldLayout.count() * (item->axisType() == ChartAxis::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() == ChartAxis::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, PieSliceItem *sliceItem, const PieSliceData &sliceData, bool isEmpty)
+            void ChartAnimator::addAnimation(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData, bool startupAnimation)
             {
                 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
                 Q_ASSERT(animation);
-                animation->addSlice(sliceItem, sliceData, isEmpty);
+                animation->addSlice(sliceItem, sliceData, startupAnimation);
             }
             void ChartAnimator::removeAnimation(PieChartItem *item, PieSliceItem *sliceItem)
             {
                 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->removeSlice(sliceItem);
             }
-            void ChartAnimator::updateLayout(PieChartItem *item, const PieLayout &layout)
+            void ChartAnimator::updateAnimation(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData)
-                PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
-                Q_ASSERT(animation);
-                animation->updateValues(layout);
-            void ChartAnimator::updateLayout(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData)
             {
                 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->updateValue(sliceItem, sliceData);
             }
             void ChartAnimator::updateLayout(BarChartItem *item, const QVector<QRectF> &oldLayout, const QVector<QRectF> &newLayout)
             {
                 BarAnimation *animation = static_cast<BarAnimation *>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->setDuration(duration);
                 animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout));
                 animation->setKeyValueAt(1.0, qVariantFromValue(newLayout));
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             void ChartAnimator::setState(State state, const QPointF &point)
             {
                 m_state = state;
                 m_point = point;
             }
             #include "moc_chartanimator_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/chartanimator_p.h +1 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef CHARTANIMATOR_P_H
             #define CHARTANIMATOR_P_H
             #include "qchartglobal.h"
             #include "chartanimation_p.h"
             #include "piechartitem_p.h"
             #include "barchartitem_p.h"
             #include <QPointF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class ChartAxis;
             class AreaChartItem;
             class SplineChartItem;
             class ScatterChartItem;
             class LineChartItem;
             class XYChartItem;
             class ChartAnimator : public QObject
             {
                 Q_OBJECT
             public:
                 enum State{ShowState, ScrollUpState, ScrollDownState, ScrollLeftState, ScrollRightState, ZoomInState, ZoomOutState};
                 ChartAnimator(QObject *parent = 0);
                 virtual ~ChartAnimator();
                 void addAnimation(ChartAxis *item);
                 void addAnimation(PieChartItem *item);
                 void addAnimation(ScatterChartItem *item);
                 void addAnimation(LineChartItem *item);
                 void addAnimation(SplineChartItem *item);
                 void addAnimation(BarChartItem *item);
                 void removeAnimation(Chart *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 updateLayout(ChartAxis *item, QVector<qreal> &layout);
                 void addAnimation(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData, bool isEmpty);
                 void removeAnimation(PieChartItem *item, PieSliceItem *sliceItem);
-                void updateLayout(PieChartItem *item, const PieLayout &layout);
+                void updateAnimation(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData);
-                void updateLayout(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData);
                 void updateLayout(BarChartItem *item, const QVector<QRectF> &oldLayout, const QVector<QRectF> &newLayout);
                 void setState(State state,const QPointF &point = QPointF());
             private:
                  QMap<Chart *, ChartAnimation *> m_animations;
                  State m_state;
                  QPointF m_point;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/animations/pieanimation.cpp +2 -8

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "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(const PieLayout &newValues)
-                foreach (PieSliceItem *s, newValues.keys())
-                    updateValue(s, newValues.value(s));
             void PieAnimation::updateValue(PieSliceItem *sliceItem, const PieSliceData &sliceData)
             {
                 PieSliceAnimation *animation = m_animations.value(sliceItem);
                 Q_ASSERT(animation);
                 animation->stop();
                 animation->updateValue(sliceData);
                 animation->setDuration(1000);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
-            void PieAnimation::addSlice(PieSliceItem *sliceItem, const PieSliceData &sliceData, bool isEmpty)
+            void PieAnimation::addSlice(PieSliceItem *sliceItem, const PieSliceData &sliceData, bool startupAnimation)
             {
                 PieSliceAnimation *animation = new PieSliceAnimation(sliceItem);
                 m_animations.insert(sliceItem, animation);
                 PieSliceData startValue = sliceData;
                 startValue.m_radius = 0;
-                if (isEmpty)
+                if (startupAnimation)
                     startValue.m_startAngle = 0;
                 else
                     startValue.m_startAngle = sliceData.m_startAngle + (sliceData.m_angleSpan / 2);
                 startValue.m_angleSpan = 0;
                 animation->setValue(startValue, sliceData);
                 animation->setDuration(1000);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             void PieAnimation::removeSlice(PieSliceItem *sliceItem)
             {
                 PieSliceAnimation *animation = m_animations.value(sliceItem);
                 Q_ASSERT(animation);
                 animation->stop();
                 PieSliceData endValue = animation->currentSliceValue();
                 endValue.m_radius = 0;
                 endValue.m_startAngle = endValue.m_startAngle + endValue.m_angleSpan;
                 endValue.m_angleSpan = 0;
                 animation->updateValue(endValue);
                 animation->setDuration(1000);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 // PieSliceItem is the parent of PieSliceAnimation so the animation will be deleted as well..
                 connect(animation, SIGNAL(finished()), sliceItem, SLOT(deleteLater()));
                 m_animations.remove(sliceItem);
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             void PieAnimation::updateCurrentValue(const QVariant &)
             {
                 // nothing to do...
             }
             #include "moc_pieanimation_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/pieanimation_p.h +1 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef 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(const PieLayout &newValues);
                 void updateValue(PieSliceItem *sliceItem, const PieSliceData &newValue);
-                void addSlice(PieSliceItem *sliceItem, const PieSliceData &endValue, bool isEmpty);
+                void addSlice(PieSliceItem *sliceItem, const PieSliceData &endValue, bool startupAnimation);
                 void removeSlice(PieSliceItem *sliceItem);
             public: // from QVariantAnimation
                 void updateCurrentValue(const QVariant &value);
             private:
                 PieChartItem *m_item;
                 QHash<PieSliceItem *, PieSliceAnimation *> m_animations;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/animations/piesliceanimation.cpp +1 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "piesliceanimation_p.h"
             #include "piechartitem_p.h"
             Q_DECLARE_METATYPE(QTCOMMERCIALCHART_NAMESPACE::PieSliceData)
             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(PieSliceItem *sliceItem)
                 :QVariantAnimation(sliceItem),
                 m_sliceItem(sliceItem)
             {
             }
             PieSliceAnimation::~PieSliceAnimation()
             {
             }
             void PieSliceAnimation::setValue(const PieSliceData &startValue, const PieSliceData &endValue)
             {
                 if (state() != QAbstractAnimation::Stopped)
                     stop();
                 m_currentValue = startValue;
                 setKeyValueAt(0.0, qVariantFromValue(startValue));
                 setKeyValueAt(1.0, qVariantFromValue(endValue));
             }
             void PieSliceAnimation::updateValue(const PieSliceData &endValue)
             {
                 if (state() != QAbstractAnimation::Stopped)
                     stop();
                 setKeyValueAt(0.0, qVariantFromValue(m_currentValue));
                 setKeyValueAt(1.0, qVariantFromValue(endValue));
             }
             PieSliceData PieSliceAnimation::currentSliceValue()
             {
                 // 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
             {
                 PieSliceData startValue = qVariantValue<PieSliceData>(start);
                 PieSliceData endValue = qVariantValue<PieSliceData>(end);
                 PieSliceData 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_slicePen = linearPos(startValue.m_slicePen, endValue.m_slicePen, progress);
                 result.m_sliceBrush = linearPos(startValue.m_sliceBrush, endValue.m_sliceBrush, progress);
                 return qVariantFromValue(result);
             }
             void PieSliceAnimation::updateCurrentValue(const QVariant &value)
             {
                 if (state() != QAbstractAnimation::Stopped) { //workaround
                     m_currentValue = qVariantValue<PieSliceData>(value);
-                    m_sliceItem->setSliceData(m_currentValue);
+                    m_sliceItem->setLayout(m_currentValue);
-                    m_sliceItem->updateGeometry();
-                    m_sliceItem->update();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechartitem.cpp +60 -108

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "piechartitem_p.h"
             #include "piesliceitem_p.h"
             #include "qpieslice.h"
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter* presenter)
                 :ChartItem(presenter),
                 m_series(series)
             {
                 Q_ASSERT(series);
                 QPieSeriesPrivate *d = QPieSeriesPrivate::seriesData(*series);
                 connect(d, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
                 connect(d, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
-                connect(d, SIGNAL(piePositionChanged()), this, SLOT(handlePieLayoutChanged()));
+                connect(d, SIGNAL(piePositionChanged()), this, SLOT(updateLayout()));
-                connect(d, SIGNAL(pieSizeChanged()), this, SLOT(handlePieLayoutChanged()));
+                connect(d, SIGNAL(pieSizeChanged()), this, SLOT(updateLayout()));
                 QTimer::singleShot(0, this, SLOT(initialize())); // TODO: get rid of this
                 // 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 *)
+            void PieChartItem::handleGeometryChanged(const QRectF& rect)
             {
-                Q_UNUSED(painter)
+                prepareGeometryChange();
-                // TODO: paint shadows for all components
+                m_rect = rect;
-                // - get paths from items & merge & offset and draw with shadow color?
+                updateLayout();
-                //painter->setBrush(QBrush(Qt::red));
-                //painter->drawRect(m_debugRect);
             }
             void PieChartItem::initialize()
             {
                 handleSlicesAdded(m_series->slices());
             }
-            void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
+            void PieChartItem::updateLayout()
             {
-                bool isEmpty = m_slices.isEmpty();
+                // find pie center coordinates
+                m_pieCenter.setX(m_rect.left() + (m_rect.width() * m_series->horizontalPosition()));
+                m_pieCenter.setY(m_rect.top() + (m_rect.height() * m_series->verticalPosition()));
+                // 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();
+                // set layouts for existing slice items
+                foreach (QPieSlice* slice, m_series->slices()) {
+                    PieSliceItem *sliceItem = m_sliceItems.value(slice);
+                    if (sliceItem) {
+                        PieSliceData sliceData = updateSliceGeometry(slice);
+                        if (animator())
+                            animator()->updateAnimation(this, sliceItem, sliceData);
+                        else
+                            sliceItem->setLayout(sliceData);
+                    }
+                }
+                update();
+            }
+            void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
+            {
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
-                foreach (QPieSlice *s, slices) {
+                bool startupAnimation = m_sliceItems.isEmpty();
-                    PieSliceItem* item = new PieSliceItem(this);
-                    m_slices.insert(s, item);
-                    connect(s, SIGNAL(changed()), this, SLOT(handleSliceChanged()));
-                    connect(item, SIGNAL(clicked(Qt::MouseButtons)), s, SIGNAL(clicked()));
-                    connect(item, SIGNAL(hovered(bool)), s, SIGNAL(hovered(bool)));
-                    PieSliceData data = sliceData(s);
+                foreach (QPieSlice *slice, slices) {
+                    PieSliceItem* sliceItem = new PieSliceItem(this);
+                    m_sliceItems.insert(slice, sliceItem);
+                    connect(slice, SIGNAL(changed()), this, SLOT(handleSliceChanged()));
+                    connect(sliceItem, SIGNAL(clicked(Qt::MouseButtons)), slice, SIGNAL(clicked()));
+                    connect(sliceItem, SIGNAL(hovered(bool)), slice, SIGNAL(hovered(bool)));
+                    PieSliceData sliceData = updateSliceGeometry(slice);
                     if (animator())
-                        animator()->addAnimation(this, item, data, isEmpty);
+                        animator()->addAnimation(this, sliceItem, sliceData, startupAnimation);
                     else
-                        setLayout(item, data);
+                        sliceItem->setLayout(sliceData);
                 }
             }
             void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices)
             {
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 foreach (QPieSlice *slice, slices) {
+                    PieSliceItem *sliceItem = m_sliceItems.value(slice);
-                    PieSliceItem *item = m_slices.value(slice);
+                    Q_ASSERT(sliceItem);
-                    Q_ASSERT(item);
+                    m_sliceItems.remove(slice);
-                    m_slices.remove(slice);
                     if (animator())
-                        animator()->removeAnimation(this, item); // animator deletes the PieSliceItem
+                        animator()->removeAnimation(this, sliceItem); // animator deletes the PieSliceItem
                     else
-                        delete item;
+                        delete sliceItem;
                 }
             }
-            void PieChartItem::handlePieLayoutChanged()
-                PieLayout layout = calculateLayout();
-                applyLayout(layout);
-                update();
             void PieChartItem::handleSliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
-                Q_ASSERT(m_slices.contains(slice));
+                Q_ASSERT(m_sliceItems.contains(slice));
-                PieSliceData data = sliceData(slice);
-                updateLayout(m_slices.value(slice), data);
-                update();
-            void PieChartItem::handleDomainChanged(qreal, qreal, qreal, qreal)
-                // TODO
-            void PieChartItem::handleGeometryChanged(const QRectF& rect)
-                prepareGeometryChange();
-                m_rect = rect;
-                handlePieLayoutChanged();
-            void PieChartItem::calculatePieLayout()
-                // find pie center coordinates
-                m_pieCenter.setX(m_rect.left() + (m_rect.width() * m_series->horizontalPosition()));
-                m_pieCenter.setY(m_rect.top() + (m_rect.height() * m_series->verticalPosition()));
-                // find maximum radius for pie
+                PieSliceItem *sliceItem = m_sliceItems.value(slice);
-                m_pieRadius = m_rect.height() / 2;
+                PieSliceData sliceData = updateSliceGeometry(slice);
-                if (m_rect.width() < m_rect.height())
+                if (animator())
-                    m_pieRadius = m_rect.width() / 2;
+                    animator()->updateAnimation(this, sliceItem, sliceData);
+                else
+                    sliceItem->setLayout(sliceData);
-                // apply size factor
+                update();
-                m_pieRadius *= m_series->pieSize();
             }
-            PieSliceData PieChartItem::sliceData(QPieSlice *slice)
+            PieSliceData PieChartItem::updateSliceGeometry(QPieSlice *slice)
             {
-            	// TODO: This function is kid of useless now. Refactor.
+                PieSliceData &sliceData = PieSliceData::data(slice);
-                PieSliceData sliceData = PieSliceData::data(slice);
                 sliceData.m_center = PieSliceItem::sliceCenter(m_pieCenter, m_pieRadius, slice);
                 sliceData.m_radius = m_pieRadius;
                 return sliceData;
             }
-            PieLayout PieChartItem::calculateLayout()
-                calculatePieLayout();
-                PieLayout layout;
-                foreach (QPieSlice* s, m_series->slices()) {
-                    if (m_slices.contains(s)) // calculate layout only for those slices that are already visible
-                        layout.insert(m_slices.value(s), sliceData(s));
-                return layout;
-            void PieChartItem::applyLayout(const PieLayout &layout)
-                if (animator())
-                    animator()->updateLayout(this, layout);
-                else
-                    setLayout(layout);
-            void PieChartItem::updateLayout(PieSliceItem *sliceItem, const PieSliceData &sliceData)
-                if (animator())
-                    animator()->updateLayout(this, sliceItem, sliceData);
-                else
-                    setLayout(sliceItem, sliceData);
-            void PieChartItem::setLayout(const PieLayout &layout)
-                foreach (PieSliceItem *item, layout.keys()) {
-                    item->setSliceData(layout.value(item));
-                    item->updateGeometry();
-                    item->update();
-            void PieChartItem::setLayout(PieSliceItem *sliceItem, const PieSliceData &sliceData)
-                Q_ASSERT(sliceItem);
-                sliceItem->setSliceData(sliceData);
-                sliceItem->updateGeometry();
-                sliceItem->update();
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechartitem_p.h +14 -19

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef PIECHARTITEM_H
             #define PIECHARTITEM_H
             #include "qpieseries.h"
             #include "chartitem_p.h"
             #include "piesliceitem_p.h"
             class QGraphicsItem;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSlice;
             class ChartPresenter;
-            typedef QHash<PieSliceItem*, PieSliceData> PieLayout;
             class PieChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
-                // TODO: use a generic data class instead of x and y
+                explicit PieChartItem(QPieSeries *series, ChartPresenter *presenter);
-                PieChartItem(QPieSeries *series, ChartPresenter *presenter);
                 ~PieChartItem();
-            public: // from QGraphicsItem
+                // from QGraphicsItem
                 QRectF boundingRect() const { return m_rect; }
-                void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *);
+                void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *) {}
             public Q_SLOTS:
+                // from Chart
+                virtual void handleGeometryChanged(const QRectF &rect);
+                // TODO: Do we have actual need for these at all? What is the use case for pie?
+                //virtual void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
+                //virtual void rangeXChanged(qreal min, qreal max, int tickXCount);
+                //virtual void rangeYChanged(qreal min, qreal max, int tickYCount);
                 void initialize();
+                void updateLayout();
                 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:
+            private:
-                void calculatePieLayout();
+                PieSliceData updateSliceGeometry(QPieSlice *slice);
-                PieSliceData sliceData(QPieSlice *slice);
-                PieLayout calculateLayout();
-                void applyLayout(const PieLayout &layout);
-                void updateLayout(PieSliceItem *sliceItem, const PieSliceData &sliceData);
-                void setLayout(const PieLayout &layout);
-                void setLayout(PieSliceItem *sliceItem, const PieSliceData &sliceData);
             private:
-                friend class PieSliceItem;
+                QHash<QPieSlice*, PieSliceItem*> m_sliceItems;
-                QHash<QPieSlice*, PieSliceItem*> m_slices;
                 QPieSeries *m_series;
                 QRectF m_rect;
                 QPointF m_pieCenter;
                 qreal m_pieRadius;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIECHARTITEM_H

src/piechart/piesliceitem.cpp +3 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "piesliceitem_p.h"
             #include "piechartitem_p.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #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);
             }
             PieSliceItem::PieSliceItem(QGraphicsItem* parent)
                 :QGraphicsObject(parent)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::MouseButtonMask);
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieSliceItem::~PieSliceItem()
             {
             }
             QRectF PieSliceItem::boundingRect() const
             {
                 return m_boundingRect;
             }
             QPainterPath PieSliceItem::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 PieSliceItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->save();
                 painter->setClipRect(parentItem()->boundingRect());
                 painter->setPen(m_data.m_slicePen);
                 painter->setBrush(m_data.m_sliceBrush);
                 painter->drawPath(m_slicePath);
                 painter->restore();
                 if (m_data.m_isLabelVisible) {
                     painter->setClipRect(parentItem()->boundingRect());
                     painter->setPen(m_data.m_labelPen);
                     painter->drawPath(m_labelArmPath);
             		// the pen color will affect the font color as well
                     painter->setFont(m_data.m_labelFont);
                     painter->drawText(m_labelTextRect.bottomLeft(), m_data.m_labelText);
                 }
             }
             void PieSliceItem::hoverEnterEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hovered(true);
             }
             void PieSliceItem::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hovered(false);
             }
             void PieSliceItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(event->buttons());
             }
-            void PieSliceItem::setSliceData(PieSliceData sliceData)
+            void PieSliceItem::setLayout(const PieSliceData &sliceData)
             {
                 m_data = sliceData;
+                updateGeometry();
+                update();
             }
             void PieSliceItem::updateGeometry()
             {
                 if (m_data.m_radius <= 0)
                     return;
                 prepareGeometryChange();
                 // update slice path
                 qreal centerAngle;
                 QPointF armStart;
                 m_slicePath = slicePath(m_data.m_center, m_data.m_radius, m_data.m_startAngle, m_data.m_angleSpan, &centerAngle, &armStart);
                 // update text rect
                 m_labelTextRect = labelTextRect(m_data.m_labelFont, m_data.m_labelText);
                 // update label arm path
                 QPointF labelTextStart;
                 m_labelArmPath = labelArmPath(armStart, centerAngle, m_data.m_radius * m_data.m_labelArmLengthFactor, m_labelTextRect.width(), &labelTextStart);
                 // update text position
                 m_labelTextRect.moveBottomLeft(labelTextStart);
                 // update bounding rect
                 if (m_data.m_isLabelVisible)
                     m_boundingRect = m_slicePath.boundingRect().united(m_labelArmPath.boundingRect()).united(m_labelTextRect);
                 else
                     m_boundingRect = m_slicePath.boundingRect();
             }
             QPointF PieSliceItem::sliceCenter(QPointF point, qreal radius, QPieSlice *slice)
             {
                 if (slice->isExploded()) {
                     qreal centerAngle = slice->startAngle() + ((slice->endAngle() - slice->startAngle())/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 PieSliceItem::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 PieSliceItem::labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF *textStart)
             {
                 // prevent label arm pointing straight down because it will look bad
                 if (angle < 180 && angle > 170)
                     angle = 170;
                 if (angle > 180 && angle < 190)
                     angle = 190;
                 // line from slice to label
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = -qCos(angle*(PI/180)) * length;
                 QPointF parm1 = start + QPointF(dx, dy);
                 // line to underline the label
                 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, -3);
                 QPainterPath path;
                 path.moveTo(start);
                 path.lineTo(parm1);
                 path.lineTo(parm2);
                 return path;
             }
             QRectF PieSliceItem::labelTextRect(QFont font, QString text)
             {
                 QFontMetricsF fm(font);
                 return fm.boundingRect(text);
             }
             #include "moc_piesliceitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piesliceitem_p.h +5 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef PIESLICEITEM_H
             #define PIESLICEITEM_H
             #include "qchartglobal.h"
             #include "charttheme_p.h"
             #include "qpieseries.h"
             #include "pieslicedata_p.h"
             #include <QGraphicsItem>
             #include <QRectF>
             #include <QColor>
             #include <QPen>
             #define PIESLICE_LABEL_GAP 5
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieChartItem;
             class PieSliceLabel;
             class QPieSlice;
             class PieSliceItem : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 PieSliceItem(QGraphicsItem* parent = 0);
                 ~PieSliceItem();
-            public: // from QGraphicsItem
+                // 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);
+                void setLayout(const PieSliceData &sliceData);
+                static QPointF sliceCenter(QPointF point, qreal radius, QPieSlice *slice);
             Q_SIGNALS:
                 void clicked(Qt::MouseButtons buttons);
                 void hovered(bool state);
-            public:
+            private:
-                void setSliceData(PieSliceData sliceData);
                 void updateGeometry();
-                static QPointF sliceCenter(QPointF point, qreal radius, QPieSlice *slice);
                 QPainterPath slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal *centerAngle, QPointF *armStart);
                 QPainterPath labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF *textStart);
                 QRectF labelTextRect(QFont font, QString text);
             private:
                 PieSliceData m_data;
                 QRectF m_boundingRect;
                 QPainterPath m_slicePath;
                 QPainterPath m_labelArmPath;
                 QRectF m_labelTextRect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICEITEM_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