HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r668:ea2480445e4a

Rename PieSliceLayout -> PieSliceData. A "layout" is a bad name for this.

Jani Honkonen -

r668:ea2480445e4a

parent child

Context file:

r668:ea2480445e4a

Collapse all files

src/animations/chartanimator.cpp +4 -4

                 QTimer::singleShot(0,animation,SLOT(start()));
             }
-            void ChartAnimator::addAnimation(PieChartItem* item, QPieSlice *slice, const PieSliceLayout &layout, bool isEmpty)
+            void ChartAnimator::addAnimation(PieChartItem* item, QPieSlice *slice, const PieSliceData &sliceData, bool isEmpty)
             {
                 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
-                animation->addSlice(slice, layout, isEmpty);
+                animation->addSlice(slice, sliceData, isEmpty);
             }
             void ChartAnimator::removeAnimation(PieChartItem* item, QPieSlice *slice)
                 animation->updateValues(layout);
             }
-            void ChartAnimator::updateLayout(PieChartItem* item, QPieSlice *slice, const PieSliceLayout &layout)
+            void ChartAnimator::updateLayout(PieChartItem* item, QPieSlice *slice, const PieSliceData &sliceData)
             {
                 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
-                animation->updateValue(slice, layout);
+                animation->updateValue(slice, sliceData);
             }
             void ChartAnimator::setState(State state,const QPointF& point)

src/animations/chartanimator_p.h +2 -2

                 void updateLayout(SplineChartItem* item,  QVector<QPointF>& oldPoints , QVector<QPointF>& newPoints, QVector<QPointF>& oldControlPoints, QVector<QPointF>& newContorlPoints,int index);
                 void updateLayout(AxisItem* item, QVector<qreal>& layout);
-                void addAnimation(PieChartItem* item, QPieSlice *slice, const PieSliceLayout &layout, bool isEmpty);
+                void addAnimation(PieChartItem* item, QPieSlice *slice, const PieSliceData &sliceData, bool isEmpty);
                 void removeAnimation(PieChartItem* item, QPieSlice *slice);
                 void updateLayout(PieChartItem* item, const PieLayout &layout);
-                void updateLayout(PieChartItem* item, QPieSlice *slice, const PieSliceLayout &layout);
+                void updateLayout(PieChartItem* item, QPieSlice *slice, const PieSliceData &sliceData);
                 void setState(State state,const QPointF& point = QPointF());

src/animations/pieanimation.cpp +14 -14

                     updateValue(s, newValues.value(s));
             }
-            void PieAnimation::updateValue(QPieSlice *slice, const PieSliceLayout &endLayout)
+            void PieAnimation::updateValue(QPieSlice *slice, const PieSliceData &sliceData)
             {
                 PieSliceAnimation *animation = m_animations.value(slice);
                 Q_ASSERT(animation);
                 animation->stop();
-                animation->updateValue(endLayout);
+                animation->updateValue(sliceData);
                 animation->setDuration(1000);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
-            void PieAnimation::addSlice(QPieSlice *slice, const PieSliceLayout &endLayout, bool isEmpty)
+            void PieAnimation::addSlice(QPieSlice *slice, const PieSliceData &sliceData, bool isEmpty)
             {
                 PieSliceAnimation *animation = new PieSliceAnimation(m_item, slice);
                 m_animations.insert(slice, animation);
-                PieSliceLayout startLayout = endLayout;
+                PieSliceData startValue = sliceData;
-                startLayout.m_radius = 0;
+                startValue.m_radius = 0;
                 if (isEmpty)
-                    startLayout.m_startAngle = 0;
+                    startValue.m_startAngle = 0;
                 else
-                    startLayout.m_startAngle = endLayout.m_startAngle + (endLayout.m_angleSpan/2);
+                    startValue.m_startAngle = sliceData.m_startAngle + (sliceData.m_angleSpan/2);
-                startLayout.m_angleSpan = 0;
+                startValue.m_angleSpan = 0;
-                animation->setValue(startLayout, endLayout);
+                animation->setValue(startValue, sliceData);
                 animation->setDuration(1000);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 Q_ASSERT(animation);
                 animation->stop();
-                PieSliceLayout endLayout = animation->currentSliceValue();
+                PieSliceData endValue = animation->currentSliceValue();
-                endLayout.m_radius = 0;
+                endValue.m_radius = 0;
                 // TODO: find the actual angle where this slice disappears
-                endLayout.m_startAngle = endLayout.m_startAngle + endLayout.m_angleSpan;
+                endValue.m_startAngle = endValue.m_startAngle + endValue.m_angleSpan;
-                endLayout.m_angleSpan = 0;
+                endValue.m_angleSpan = 0;
-                animation->updateValue(endLayout);
+                animation->updateValue(endValue);
                 animation->setDuration(1000);
                 animation->setEasingCurve(QEasingCurve::OutQuart);

src/animations/pieanimation_p.h +2 -2

                 PieAnimation(PieChartItem *item);
                 ~PieAnimation();
                 void updateValues(const PieLayout &newValues);
-                void updateValue(QPieSlice *slice, const PieSliceLayout &newValue);
+                void updateValue(QPieSlice *slice, const PieSliceData &newValue);
-                void addSlice(QPieSlice *slice, const PieSliceLayout &endLayout, bool isEmpty);
+                void addSlice(QPieSlice *slice, const PieSliceData &endValue, bool isEmpty);
                 void removeSlice(QPieSlice *slice);
             public: // from QVariantAnimation

src/animations/piesliceanimation.cpp +8 -8

             #include "piechartitem_p.h"
             #include "qpieslice.h"
-            Q_DECLARE_METATYPE(QtCommercialChart::PieSliceLayout)
+            Q_DECLARE_METATYPE(QtCommercialChart::PieSliceData)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             {
             }
-            void PieSliceAnimation::setValue(const PieSliceLayout &startValue, const PieSliceLayout &endValue)
+            void PieSliceAnimation::setValue(const PieSliceData &startValue, const PieSliceData &endValue)
             {
                 if (state() != QAbstractAnimation::Stopped)
                     stop();
                 setKeyValueAt(1.0, qVariantFromValue(endValue));
             }
-            void PieSliceAnimation::updateValue(const PieSliceLayout &endValue)
+            void PieSliceAnimation::updateValue(const PieSliceData &endValue)
             {
                 if (state() != QAbstractAnimation::Stopped)
                     stop();
                 setKeyValueAt(1.0, qVariantFromValue(endValue));
             }
-            PieSliceLayout PieSliceAnimation::currentSliceValue()
+            PieSliceData PieSliceAnimation::currentSliceValue()
             {
                 // NOTE:
                 // We must use an internal current value because QVariantAnimation::currentValue() is updated
             QVariant PieSliceAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress) const
             {
-                PieSliceLayout startValue = qVariantValue<PieSliceLayout>(start);
+                PieSliceData startValue = qVariantValue<PieSliceData>(start);
-                PieSliceLayout endValue = qVariantValue<PieSliceLayout>(end);
+                PieSliceData endValue = qVariantValue<PieSliceData>(end);
-                PieSliceLayout result;
+                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);
             void PieSliceAnimation::updateCurrentValue(const QVariant &value)
             {
                 if (state() != QAbstractAnimation::Stopped) { //workaround
-                    m_currentValue = qVariantValue<PieSliceLayout>(value);
+                    m_currentValue = qVariantValue<PieSliceData>(value);
                     m_item->setLayout(m_slice, m_currentValue);
                 }
             }

src/animations/piesliceanimation_p.h +4 -4

             public:
                 PieSliceAnimation(PieChartItem *item, QPieSlice *slice);
                 ~PieSliceAnimation();
-                void setValue(const PieSliceLayout &startValue, const PieSliceLayout &endValue);
+                void setValue(const PieSliceData &startValue, const PieSliceData &endValue);
-                void updateValue(const PieSliceLayout &endValue);
+                void updateValue(const PieSliceData &endValue);
-                PieSliceLayout currentSliceValue();
+                PieSliceData currentSliceValue();
             protected:
                 QVariant interpolated(const QVariant &start, const QVariant &end, qreal progress) const;
             private:
                 PieChartItem *m_item;
                 QPieSlice *m_slice;
-                PieSliceLayout m_currentValue;
+                PieSliceData m_currentValue;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechartitem.cpp +36 -24

                     connect(slice, SIGNAL(hoverEnter()), s, SIGNAL(hoverEnter()));
                     connect(slice, SIGNAL(hoverLeave()), s, SIGNAL(hoverLeave()));
-                    PieSliceLayout layout = calculateSliceLayout(s);
+                    PieSliceData data = sliceData(s);
                     if (m_animator)
-                        m_animator->addAnimation(this, s, layout, isEmpty);
+                        m_animator->addAnimation(this, s, data, isEmpty);
                     else
-                        setLayout(s, layout);
+                        setLayout(s, data);
                 }
             }
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
-                PieSliceLayout layout = calculateSliceLayout(slice);
+                PieSliceData data = sliceData(slice);
-                updateLayout(slice, layout);
+                updateLayout(slice, data);
                 update();
             }
                 m_pieRadius *= m_series->pieSize();
             }
-            PieSliceLayout PieChartItem::calculateSliceLayout(QPieSlice *slice)
+            PieSliceData PieChartItem::sliceData(QPieSlice *slice)
             {
-                PieSliceLayout sliceLayout;
+                PieSliceData sliceData;
-                sliceLayout.m_center = PieSlice::sliceCenter(m_pieCenter, m_pieRadius, slice);
-                sliceLayout.m_radius = m_pieRadius;
+                // TODO:
-                sliceLayout.m_startAngle = slice->startAngle();
+                // sliceData = slice->m_data;
-                sliceLayout.m_angleSpan = slice->m_angleSpan;
-                sliceLayout.m_pen = slice->m_slicePen;
+                sliceData.m_center = PieSlice::sliceCenter(m_pieCenter, m_pieRadius, slice);
-                sliceLayout.m_brush = slice->m_sliceBrush;
+                sliceData.m_radius = m_pieRadius;
-                return sliceLayout;
+                sliceData.m_startAngle = slice->startAngle();
+                sliceData.m_angleSpan = slice->m_angleSpan;
+                sliceData.m_pen = slice->m_slicePen;
+                sliceData.m_brush = slice->m_sliceBrush;
+                sliceData.m_isExploded = slice->isExploded();
+                sliceData.m_explodeDistanceFactor = slice->explodeDistanceFactor();
+                sliceData.m_labelVisible = slice->isLabelVisible();
+                sliceData.m_labelText = slice->label();
+                sliceData.m_labelFont = slice->labelFont();
+                sliceData.m_labelArmLengthFactor = slice->labelArmLengthFactor();
+                sliceData.m_labelArmPen = slice->labelArmPen();
+                return sliceData;
             }
             PieLayout PieChartItem::calculateLayout()
                 PieLayout layout;
                 foreach (QPieSlice* s, m_series->slices()) {
                     if (m_slices.contains(s)) // calculate layout only for those slices that are already visible
-                        layout.insert(s, calculateSliceLayout(s));
+                        layout.insert(s, sliceData(s));
                 }
                 return layout;
             }
                     setLayout(layout);
             }
-            void PieChartItem::updateLayout(QPieSlice *slice, const PieSliceLayout &layout)
+            void PieChartItem::updateLayout(QPieSlice *slice, const PieSliceData &sliceData)
             {
                 if (m_animator)
-                    m_animator->updateLayout(this, slice, layout);
+                    m_animator->updateLayout(this, slice, sliceData);
                 else
-                    setLayout(slice, layout);
+                    setLayout(slice, sliceData);
             }
             void PieChartItem::setLayout(const PieLayout &layout)
                 foreach (QPieSlice *slice, layout.keys()) {
                     PieSlice *s = m_slices.value(slice);
                     Q_ASSERT(s);
-                    s->setLayout(layout.value(slice));
+                    s->setSliceData(layout.value(slice));
-                    s->updateData(slice);
                     s->updateGeometry();
                     s->update();
                 }
             }
-            void PieChartItem::setLayout(QPieSlice *slice, const PieSliceLayout &layout)
+            void PieChartItem::setLayout(QPieSlice *slice, const PieSliceData &sliceData)
             {
                 // find slice
                 PieSlice *s = m_slices.value(slice);
                 Q_ASSERT(s);
-                s->setLayout(layout);
+                s->setSliceData(sliceData);
-                if (m_series->m_slices.contains(slice)) // Slice has been deleted if not found. Animations ongoing...
-                    s->updateData(slice);
                 s->updateGeometry();
                 s->update();
             }

src/piechart/piechartitem_p.h +4 -4

             class QPieSlice;
             class ChartPresenter;
-            typedef QHash<QPieSlice*, PieSliceLayout> PieLayout;
+            typedef QHash<QPieSlice*, PieSliceData> PieLayout;
             class PieChartItem : public QObject, public ChartItem
             {
             public:
                 void calculatePieLayout();
-                PieSliceLayout calculateSliceLayout(QPieSlice *slice);
+                PieSliceData sliceData(QPieSlice *slice);
                 PieLayout calculateLayout();
                 void applyLayout(const PieLayout &layout);
-                void updateLayout(QPieSlice *slice, const PieSliceLayout &layout);
+                void updateLayout(QPieSlice *slice, const PieSliceData &sliceData);
                 void setLayout(const PieLayout &layout);
-                void setLayout(QPieSlice *slice, const PieSliceLayout &layout);
+                void setLayout(QPieSlice *slice, const PieSliceData &sliceData);
                 void destroySlice(QPieSlice *slice);
             private:

src/piechart/pieslice.cpp +13 -31

             }
             PieSlice::PieSlice(QGraphicsItem* parent)
-                :QGraphicsObject(parent),
+                :QGraphicsObject(parent)
-                m_isExploded(false),
-                m_explodeDistanceFactor(0),
-                m_labelVisible(false),
-                m_labelArmLengthFactor(0)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::LeftButton);
                 painter->setClipRect(parentItem()->boundingRect());
                 painter->save();
-                painter->setPen(m_layout.m_pen);
+                painter->setPen(m_data.m_pen);
-                painter->setBrush(m_layout.m_brush);
+                painter->setBrush(m_data.m_brush);
                 painter->drawPath(m_slicePath);
                 painter->restore();
-                if (m_labelVisible) {
+                if (m_data.m_labelVisible) {
                     painter->save();
-                    painter->setPen(m_labelArmPen);
+                    painter->setPen(m_data.m_labelArmPen);
                     painter->drawPath(m_labelArmPath);
                     painter->restore();
-                    painter->setFont(m_labelFont);
+                    painter->setFont(m_data.m_labelFont);
-                    painter->drawText(m_labelTextRect.bottomLeft(), m_labelText);
+                    painter->drawText(m_labelTextRect.bottomLeft(), m_data.m_labelText);
                 }
             }
                 emit clicked();
             }
-            void PieSlice::setLayout(PieSliceLayout layout)
+            void PieSlice::setSliceData(PieSliceData sliceData)
             {
-                m_layout = layout;
+                m_data = sliceData;
             }
             void PieSlice::updateGeometry()
             {
-                if (m_layout.m_radius <= 0)
+                if (m_data.m_radius <= 0)
                     return;
                 prepareGeometryChange();
                 // update slice path
                 qreal centerAngle;
                 QPointF armStart;
-                m_slicePath = slicePath(m_layout.m_center, m_layout.m_radius, m_layout.m_startAngle, m_layout.m_angleSpan, &centerAngle, &armStart);
+                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_labelFont, m_labelText);
+                m_labelTextRect = labelTextRect(m_data.m_labelFont, m_data.m_labelText);
                 // update label arm path
                 QPointF labelTextStart;
-                m_labelArmPath = labelArmPath(armStart, centerAngle, m_layout.m_radius * m_labelArmLengthFactor, m_labelTextRect.width(), &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);
                 m_boundingRect = m_slicePath.boundingRect().united(m_labelArmPath.boundingRect()).united(m_labelTextRect);
             }
-            void PieSlice::updateData(const QPieSlice* sliceData)
-                // TODO: compare what has changes to avoid unneccesary geometry updates
-                m_isExploded = sliceData->isExploded();
-                m_explodeDistanceFactor = sliceData->explodeDistanceFactor();
-                m_labelVisible = sliceData->isLabelVisible();
-                m_labelText = sliceData->label();
-                m_labelFont = sliceData->labelFont();
-                m_labelArmLengthFactor = sliceData->labelArmLengthFactor();
-                m_labelArmPen = sliceData->labelArmPen();
             QPointF PieSlice::sliceCenter(QPointF point, qreal radius, QPieSlice *slice)
             {
                 if (slice->isExploded()) {

src/piechart/pieslice_p.h +13 -14

             class PieSliceLabel;
             class QPieSlice;
-            class PieSliceLayout
+            class PieSliceData
             {
             public:
                 QPointF m_center;
                 qreal m_radius;
                 qreal m_startAngle;
                 qreal m_angleSpan;
                 QPen m_pen;
                 QBrush m_brush;
+                bool m_isExploded;
+                qreal m_explodeDistanceFactor;
+                bool m_labelVisible;
+                QString m_labelText;
+                QFont m_labelFont;
+                qreal m_labelArmLengthFactor;
+                QPen m_labelArmPen;
             };
             class PieSlice : public QGraphicsObject
                 void hoverLeave();
             public:
-                void setLayout(PieSliceLayout layout);
+                void setSliceData(PieSliceData sliceData);
                 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;
+                PieSliceData m_data;
                 QRectF m_boundingRect;
                 QPainterPath m_slicePath;
-                bool m_isExploded;
-                qreal m_explodeDistanceFactor;
-                bool m_labelVisible;
                 QPainterPath m_labelArmPath;
-                qreal m_labelArmLengthFactor;
-                QPen m_labelArmPen;
                 QRectF m_labelTextRect;
-                QFont m_labelFont;
-                QString m_labelText;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages