HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1735:0a19606ca1b1

Refactor animator...

Michal Klocek -

r1735:0a19606ca1b1

parent child

Context file:

r1735:0a19606ca1b1

Expand all files

src/animations/animations.pri 0 -2

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/axisanimation.cpp \
-                $$PWD/chartanimator.cpp \
                 $$PWD/xyanimation.cpp \
                 $$PWD/pieanimation.cpp \
                 $$PWD/piesliceanimation.cpp \
                 $$PWD/splineanimation.cpp \
                 $$PWD/baranimation.cpp \
                 $$PWD/stackedbaranimation.cpp \
                 $$PWD/percentbaranimation.cpp \
                 $$PWD/abstractbaranimation.cpp \
                 $$PWD/horizontalbaranimation.cpp \
                 $$PWD/horizontalstackedbaranimation.cpp \
                 $$PWD/horizontalpercentbaranimation.cpp
             PRIVATE_HEADERS += \
                 $$PWD/axisanimation_p.h \
-                $$PWD/chartanimator_p.h \
                 $$PWD/chartanimation_p.h \
                 $$PWD/xyanimation_p.h \
                 $$PWD/pieanimation_p.h \
                 $$PWD/piesliceanimation_p.h \
                 $$PWD/splineanimation_p.h \
                 $$PWD/baranimation_p.h \
                 $$PWD/stackedbaranimation_p.h \
                 $$PWD/percentbaranimation_p.h \
                 $$PWD/abstractbaranimation_p.h \
                 $$PWD/horizontalbaranimation_p.h \
                 $$PWD/horizontalstackedbaranimation_p.h \
                 $$PWD/horizontalpercentbaranimation_p.h

src/animations/pieanimation.cpp +7 -6

             /****************************************************************************
             **
             ** 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 <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieAnimation::PieAnimation(PieChartItem *item)
                 :ChartAnimation(item),
                 m_item(item)
             {
             }
             PieAnimation::~PieAnimation()
             {
             }
-            void PieAnimation::updateValue(PieSliceItem *sliceItem, const PieSliceData &sliceData)
+            ChartAnimation* PieAnimation::updateValue(PieSliceItem *sliceItem, const PieSliceData &sliceData)
             {
                 PieSliceAnimation *animation = m_animations.value(sliceItem);
                 Q_ASSERT(animation);
                 animation->stop();
                 animation->updateValue(sliceData);
                 animation->setDuration(ChartAnimationDuration);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
-                QTimer::singleShot(0, animation, SLOT(start()));
+                return animation;
             }
-            void PieAnimation::addSlice(PieSliceItem *sliceItem, const PieSliceData &sliceData, bool startupAnimation)
+            ChartAnimation* 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 (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(ChartAnimationDuration);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
-                QTimer::singleShot(0, animation, SLOT(start()));
+                return animation;
             }
-            void PieAnimation::removeSlice(PieSliceItem *sliceItem)
+            ChartAnimation* 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;
                 endValue.m_isLabelVisible = false;
                 animation->updateValue(endValue);
                 animation->setDuration(ChartAnimationDuration);
                 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()));
+                return animation;
             }
             void PieAnimation::updateCurrentValue(const QVariant &)
             {
                 // nothing to do...
             }
             #include "moc_pieanimation_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/pieanimation_p.h +3 -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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #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 updateValue(PieSliceItem *sliceItem, const PieSliceData &newValue);
+                ChartAnimation* updateValue(PieSliceItem *sliceItem, const PieSliceData &newValue);
-                void addSlice(PieSliceItem *sliceItem, const PieSliceData &endValue, bool startupAnimation);
+                ChartAnimation* addSlice(PieSliceItem *sliceItem, const PieSliceData &endValue, bool startupAnimation);
-                void removeSlice(PieSliceItem *sliceItem);
+                ChartAnimation* 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 -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 "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),
+                :ChartAnimation(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->setLayout(m_currentValue);
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/piesliceanimation_p.h +2 -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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef PIESLICEANIMATION_P_H
             #define PIESLICEANIMATION_P_H
-            #include <QVariantAnimation>
+            #include "chartanimation_p.h"
             #include "piesliceitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieChartItem;
-            class PieSliceAnimation : public QVariantAnimation
+            class PieSliceAnimation : public ChartAnimation
             {
             public:
                 PieSliceAnimation(PieSliceItem *sliceItem);
                 ~PieSliceAnimation();
                 void setValue(const PieSliceData &startValue, const PieSliceData &endValue);
                 void updateValue(const PieSliceData &endValue);
                 PieSliceData currentSliceValue();
             protected:
                 QVariant interpolated(const QVariant &start, const QVariant &end, qreal progress) const;
                 void updateCurrentValue(const QVariant &value);
             private:
                 PieSliceItem *m_sliceItem;
                 PieSliceData m_currentValue;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/areachart/qareaseries.cpp 0 -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 "qareaseries.h"
             #include "qareaseries_p.h"
             #include "qlineseries.h"
             #include "areachartitem_p.h"
             #include "legendmarker_p.h"
             #include "domain_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
-            #include "chartanimator_p.h"
             #include "qvaluesaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAreaSeries
                 \brief The QAreaSeries class is used for making area charts.
                 \mainclass
             	An area chart is used to show quantitative data. It is based on line chart, in the way that area between axis and the line
             	is emphasized with color. Since the area chart is based on line chart, QAreaSeries constructor needs QLineSeries instance,
             	which defines "upper" boundary of the area. "Lower" boundary is defined by default by axis X. Instead of axis X "lower" boundary can be specified by other line.
                 In that case QAreaSeries should be initiated with two QLineSeries instances. Please note terms "upper" and "lower" boundary can be misleading in cases
             	where "lower" boundary had bigger values than the "upper" one, however the main point that area between these two boundary lines will be filled.
                 See the \l {AreaChart Example} {area chart example} to learn how to create a simple area chart.
                 \image examples_areachart.png
             */
             /*!
                 \qmlclass AreaSeries QAreaSeries
                 The following QML shows how to create a simple area chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View4.qml 1
                 \beginfloatleft
                 \image demos_qmlchart4.png
                 \endfloat
                 \clearfloat
             */
             /*!
                \property QAreaSeries::upperSeries
                \brief The upper one of the two line series used to define area series boundaries.
             */
             /*!
                \qmlproperty LineSeries AreaSeries::upperSeries
                The upper one of the two line series used to define area series boundaries.
             */
             /*!
                 \property QAreaSeries::lowerSeries
                 The lower one of the two line series used to define are series boundaries. Note if
                 QAreaSeries was counstucted wihtout a\ lowerSeries this is null.
             */
             /*!
                 \qmlproperty LineSeries AreaSeries::lowerSeries
                 The lower one of the two line series used to define are series boundaries. Note if
                 AreaSeries was counstucted wihtout a\ lowerSeries this is null.
             */
             /*!
                 \property QAreaSeries::color
                 Fill (brush) color of the series. This is a convenience property for modifying the color of brush.
                 \sa QAreaSeries::brush()
             */
             /*!
                 \qmlproperty color AreaSeries::color
                 Fill (brush) color of the series.
             */
             /*!
                 \property QAreaSeries::borderColor
                 Line (pen) color of the series. This is a convenience property for modifying the color of pen.
                 \sa QAreaSeries::pen()
             */
             /*!
                 \qmlproperty color AreaSeries::borderColor
                 Line (pen) color of the series.
             */
             /*!
                \fn QPen QAreaSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn QPen QAreaSeries::brush() const
                \brief  Returns the brush used to draw line for this series.
                 \sa setBrush()
             */
             /*!
                 \fn void QAreaSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the fill (brush) color has changed to \a color.
             */
             /*!
                 \qmlsignal AreaSeries::onColorChanged(color color)
                 Signal is emitted when the fill (brush) color has changed to \a color.
             */
             /*!
                 \fn void QAreaSeries::borderColorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \qmlsignal AreaSeries::onBorderColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn void QAreaSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on area chart.
             */
             /*!
                 \qmlsignal AreaSeries::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on area chart.
             */
             /*!
                 \fn void QAreaSeries::selected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of QAreaSeries API.
             */
             /*!
                 \qmlsignal AreaSeries::onSelected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of AreaSeries API.
             */
             /*!
                 \fn void QAreaSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 Constructs area series object which is a child of \a upperSeries. Area will be spanned between \a
                 upperSeries line and \a lowerSeries line.  If no \a lowerSeries is passed to constructor, area is specified by axis x (y=0) instead.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QAreaSeries::QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries)
                 : QAbstractSeries(*new QAreaSeriesPrivate(upperSeries,lowerSeries,this),upperSeries)
             {
             }
             /*!
                 Constructs area series object without upper or lower series with \a parent object.
             */
             QAreaSeries::QAreaSeries(QObject *parent)
                 : QAbstractSeries(*new QAreaSeriesPrivate(0, 0, this), parent)
             {
             }
             /*!
                 Destroys the object.
             */
             QAreaSeries::~QAreaSeries()
             {
                 Q_D(QAreaSeries);
                 if(d->m_dataset){
                        d->m_dataset->removeSeries(this);
                 }
             }
             /*!
                 Returns QChartSeries::SeriesTypeArea.
             */
             QAbstractSeries::SeriesType QAreaSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeArea;
             }
             /*!
                 Sets the \a series that is to be used as the area chart upper series.
             */
             void QAreaSeries::setUpperSeries(QLineSeries* series)
             {
                 Q_D(QAreaSeries);
                 d->m_upperSeries = series;
             }
             QLineSeries* QAreaSeries::upperSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_upperSeries;
             }
             /*!
                 Sets the \a series that is to be used as the area chart lower series.
             */
             void QAreaSeries::setLowerSeries(QLineSeries* series)
             {
                 Q_D(QAreaSeries);
                 d->m_lowerSeries = series;
             }
             QLineSeries* QAreaSeries::lowerSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_lowerSeries;
             }
             /*!
                 Sets \a pen used for drawing area outline.
             */
             void QAreaSeries::setPen(const QPen &pen)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pen != pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen  QAreaSeries::pen() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for filling the area.
             */
             void QAreaSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QAreaSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QAreaSeries::brush() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_brush;
             }
             void QAreaSeries::setColor(const QColor &color)
             {
                 QBrush b = brush();
                 if (b.color() != color) {
                     b.setColor(color);
                     setBrush(b);
                     emit colorChanged(color);
                 }
             }
             QColor QAreaSeries::color() const
             {
                 return brush().color();
             }
             void QAreaSeries::setBorderColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             QColor QAreaSeries::borderColor() const
             {
                 return pen().color();
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QAreaSeries::setPointsVisible(bool visible)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             /*!
                 Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             bool QAreaSeries::pointsVisible() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointsVisible;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries,QAreaSeries* q) :
                 QAbstractSeriesPrivate(q),
                 m_upperSeries(upperSeries),
                 m_lowerSeries(lowerSeries),
                 m_pointsVisible(false)
             {
             }
             void QAreaSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_Q(QAreaSeries);
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 QLineSeries* upperSeries = q->upperSeries();
                 QLineSeries* lowerSeries = q->lowerSeries();
                 const QList<QPointF>& points = upperSeries->points();
                 for (int i = 0; i < points.count(); i++)
                 {
                     qreal x = points[i].x();
                     qreal y = points[i].y();
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                 if(lowerSeries) {
                     const QList<QPointF>& points = lowerSeries->points();
                     for (int i = 0; i < points.count(); i++)
                     {
                         qreal x = points[i].x();
                         qreal y = points[i].y();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                     }}
                 domain.setRange(minX,maxX,minY,maxY);
             }
             Chart* QAreaSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem* area = new AreaChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
-                    area->upperLineItem()->setAnimator(presenter->animator());
                     area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem()));
                     if(q->lowerSeries())  {
-                        area->lowerLineItem()->setAnimator(presenter->animator());
                         area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem()));
                     }
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return area;
             }
             QList<LegendMarker*> QAreaSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QAreaSeries);
                 QList<LegendMarker*> list;
                 return list << new AreaLegendMarker(q,legend);
             }
             void QAreaSeriesPrivate::initializeAxis(QAbstractAxis* axis)
             {
                 Q_UNUSED(axis);
             }
             QAbstractAxis::AxisType QAreaSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValues;
             }
             #include "moc_qareaseries.cpp"
             #include "moc_qareaseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxis.cpp 0 -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 "chartaxis_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
-            #include "chartanimator_p.h"
             #include "domain_p.h"
             #include <qmath.h>
             #include <QDateTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxis::ChartAxis(QAbstractAxis *axis,ChartPresenter *presenter) : Chart(presenter),
                 m_chartAxis(axis),
                 m_labelsAngle(0),
                 m_grid(new QGraphicsItemGroup(presenter->rootItem())),
                 m_shades(new QGraphicsItemGroup(presenter->rootItem())),
                 m_labels(new QGraphicsItemGroup(presenter->rootItem())),
                 m_arrow(new QGraphicsItemGroup(presenter->rootItem())),
                 m_min(0),
                 m_max(0),
                 m_animation(0),
                 m_minWidth(0),
                 m_minHeight(0)
             {
                 //initial initialization
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_arrow->setHandlesChildEvents(false);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 QObject::connect(m_chartAxis->d_ptr.data(),SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
                 QGraphicsSimpleTextItem item;
                 m_font = item.font();
             }
             ChartAxis::~ChartAxis()
             {
             }
             void ChartAxis::setAnimation(AxisAnimation* animation)
             {
                 m_animation=animation;
             }
             void ChartAxis::setLayout(QVector<qreal> &layout)
             {
                 m_layoutVector=layout;
             }
             void ChartAxis::createItems(int count)
             {
                 if (m_arrow->children().size() == 0)
                 m_arrow->addToGroup(new AxisItem(this));
                 for (int i = 0; i < count; ++i) {
                     m_grid->addToGroup(new QGraphicsLineItem());
                     m_labels->addToGroup(new QGraphicsSimpleTextItem());
                     m_arrow->addToGroup(new QGraphicsLineItem());
                     if ((m_grid->childItems().size())%2 && m_grid->childItems().size()>2) m_shades->addToGroup(new QGraphicsRectItem());
                 }
             }
             void ChartAxis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 for (int i = 0; i < count; ++i) {
                     if (lines.size()%2 && lines.size() > 1) delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void ChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 int diff = m_layoutVector.size() - layout.size();
                 if (diff>0) {
                     deleteItems(diff);
                 }
                 else if (diff<0) {
                     createItems(-diff);
                 }
                 if(diff<0) handleAxisUpdated();
                 if (m_animation) {
                       switch(presenter()->state()){
                           case ChartPresenter::ZoomInState:
                               m_animation->setAnimationType(AxisAnimation::ZoomInAnimation);
                               m_animation->setAnimationPoint(presenter()->statePoint());
                               break;
                           case ChartPresenter::ZoomOutState:
                               m_animation->setAnimationType(AxisAnimation::ZoomOutAnimation);
                               m_animation->setAnimationPoint(presenter()->statePoint());
                               break;
                           case ChartPresenter::ScrollUpState:
                           case ChartPresenter::ScrollLeftState:
                               m_animation->setAnimationType(AxisAnimation::MoveBackwordAnimation);
                               break;
                           case ChartPresenter::ScrollDownState:
                           case ChartPresenter::ScrollRightState:
                               m_animation->setAnimationType(AxisAnimation::MoveForwardAnimation);
                               break;
                           case ChartPresenter::ShowState:
                               m_animation->setAnimationType(AxisAnimation::DefaultAnimation);
                               break;
                       }
                       m_animation->setValues(m_layoutVector,layout);
                       presenter()->startAnimation(m_animation);
                 }
                 else {
                     setLayout(layout);
                     updateGeometry();
                 }
             }
             void ChartAxis::setArrowOpacity(qreal opacity)
             {
                 m_arrow->setOpacity(opacity);
             }
             qreal ChartAxis::arrowOpacity() const
             {
                 return m_arrow->opacity();
             }
             void ChartAxis::setArrowVisibility(bool visible)
             {
                 m_arrow->setOpacity(visible);
             }
             void ChartAxis::setGridOpacity(qreal opacity)
             {
                 m_grid->setOpacity(opacity);
             }
             qreal ChartAxis::gridOpacity() const
             {
                 return m_grid->opacity();
             }
             void ChartAxis::setGridVisibility(bool visible)
             {
                 m_grid->setOpacity(visible);
             }
             void ChartAxis::setLabelsOpacity(qreal opacity)
             {
                 m_labels->setOpacity(opacity);
             }
             qreal ChartAxis::labelsOpacity() const
             {
                 return m_labels->opacity();
             }
             void ChartAxis::setLabelsVisibility(bool visible)
             {
                 m_labels->setOpacity(visible);
             }
             void ChartAxis::setShadesOpacity(qreal opacity)
             {
                 m_shades->setOpacity(opacity);
             }
             qreal ChartAxis::shadesOpacity() const
             {
                 return m_shades->opacity();
             }
             void ChartAxis::setShadesVisibility(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxis::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
             void ChartAxis::setLabelsPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setLabelsBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
             void ChartAxis::setLabelsFont(const QFont &font)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
                 m_font = font;
             }
             void ChartAxis::setShadesBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
             void ChartAxis::setShadesPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setArrowPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_arrow->childItems()) {
                        static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setGridPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_grid->childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             bool ChartAxis::isEmpty()
             {
                 return m_rect.isEmpty() || qFuzzyIsNull(m_min - m_max);
             }
             void ChartAxis::handleDomainUpdated()
             {
                 Domain* domain = qobject_cast<Domain*>(sender());
                 qreal min(0);
                 qreal max(0);
                 if(m_chartAxis->orientation()==Qt::Horizontal) {
                     min = domain->minX();
                     max = domain->maxX();
                 }
                 else if (m_chartAxis->orientation()==Qt::Vertical)
                 {
                     min = domain->minY();
                     max = domain->maxY();
                 }
                 if (!qFuzzyIsNull(m_min - min) || !qFuzzyIsNull(m_max - max))
                 {
                     m_min = min;
                     m_max = max;
                     if (!isEmpty()) {
                         QVector<qreal> layout = calculateLayout();
                         updateLayout(layout);
                     }
                 }
             }
             void ChartAxis::handleAxisUpdated()
             {
                 if(isEmpty()) return;
                 bool visible = m_chartAxis->isVisible();
                 setArrowVisibility(visible && m_chartAxis->isArrowVisible());
                 setGridVisibility(visible && m_chartAxis->isGridLineVisible());
                 setLabelsVisibility(visible && m_chartAxis->labelsVisible());
                 setShadesVisibility(visible && m_chartAxis->shadesVisible());
                 setLabelsAngle(m_chartAxis->labelsAngle());
                 setArrowPen(m_chartAxis->axisPen());
                 setLabelsPen(m_chartAxis->labelsPen());
                 setLabelsBrush(m_chartAxis->labelsBrush());
                 setLabelsFont(m_chartAxis->labelsFont());
                 setGridPen(m_chartAxis->gridLinePen());
                 setShadesPen(m_chartAxis->shadesPen());
                 setShadesBrush(m_chartAxis->shadesBrush());
             }
             void ChartAxis::hide()
             {
                 setArrowVisibility(false);
                 setGridVisibility(false);
                 setLabelsVisibility(false);
                 setShadesVisibility(false);
             }
             void ChartAxis::handleGeometryChanged(const QRectF &rect)
             {
                 if(m_rect != rect)
                 {
                     m_rect = rect;
                     if (isEmpty()) return;
                     QVector<qreal> layout = calculateLayout();
                     updateLayout(layout);
                 }
             }
             qreal ChartAxis::minimumWidth()
             {
                 if(m_minWidth == 0) updateGeometry();
                 return m_minWidth;
             }
             qreal ChartAxis::minimumHeight()
             {
                 if(m_minHeight == 0) updateGeometry();
                 return m_minHeight;
             }
             void ChartAxis::axisSelected()
             {
                 qDebug()<<"TODO: axis clicked";
             }
             void ChartAxis::createNumberLabels(QStringList &labels,qreal min, qreal max, int ticks) const
             {
                 Q_ASSERT(max>min);
                 Q_ASSERT(ticks>1);
                 int n = qMax(int(-qFloor(log10((max-min)/(ticks-1)))),0);
                 n++;
                 for (int i=0; i< ticks; i++) {
                     qreal value = min + (i * (max - min)/ (ticks-1));
                     labels << QString::number(value,'f',n);
                 }
             }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/datetimeaxis/chartdatetimeaxisx.cpp +3 -5

             /****************************************************************************
             **
             ** 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 "chartdatetimeaxisx_p.h"
-            #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
-            #include "chartanimator_p.h"
             #include "qdatetimeaxis.h"
             #include <QGraphicsLayout>
-            #include <QDebug>
-            #include <QFontMetrics>
-            #include <cmath>
             #include <QDateTime>
+            #include <QFontMetrics>
+            #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDateTimeAxisX::ChartDateTimeAxisX(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_tickCount(0)
             {
             }
             ChartDateTimeAxisX::~ChartDateTimeAxisX()
             {
             }
             void ChartDateTimeAxisX::createLabels(QStringList &labels,qreal min, qreal max, int ticks)
             {
                 Q_ASSERT(max>min);
                 Q_ASSERT(ticks>1);
                 QDateTimeAxis *axis = qobject_cast<QDateTimeAxis *>(m_chartAxis);
                 int n = qMax(int(-floor(log10((max-min)/(ticks-1)))),0);
                 n++;
                 for (int i=0; i< ticks; i++) {
                     qreal value = min + (i * (max - min)/ (ticks-1));
                     labels << QDateTime::fromMSecsSinceEpoch(value).toString(axis->formatString());
                 }
             }
             QVector<qreal> ChartDateTimeAxisX::calculateLayout() const
             {
                 Q_ASSERT(m_tickCount>=2);
                 QVector<qreal> points;
                 points.resize(m_tickCount);
                 const qreal deltaX = m_rect.width()/(m_tickCount-1);
                 for (int i = 0; i < m_tickCount; ++i) {
                     int x = i * deltaX + m_rect.left();
                     points[i] = x;
                 }
                 return points;
             }
             void ChartDateTimeAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList;
                 createLabels(ticksList,m_min,m_max,layout.size());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
                 qreal width = 0;
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
                         if(labelItem->pos().x()<=width){
                             labelItem->setVisible(false);
                             lineItem->setVisible(false);
                         }else{
                             labelItem->setVisible(true);
                             lineItem->setVisible(true);
                             width=rect.width()+labelItem->pos().x();
                         }
                         m_minWidth+=rect.width();
                         m_minHeight=qMax(rect.height(),m_minHeight);
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
                         rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
                 }
             }
             void ChartDateTimeAxisX::handleAxisUpdated()
             {
                 //TODO:: fix this
                 QDateTimeAxis* axis = qobject_cast<QDateTimeAxis*>(m_chartAxis);
                 m_tickCount = axis->ticksCount();
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/datetimeaxis/chartdatetimeaxisy.cpp +2 -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$
             **
             ****************************************************************************/
             #include "chartdatetimeaxisy_p.h"
-            #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
-            #include "chartanimator_p.h"
             #include "qdatetimeaxis.h"
             #include <QGraphicsLayout>
-            #include <QDebug>
             #include <QFontMetrics>
-            #include <cmath>
             #include <QDateTime>
+            #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDateTimeAxisY::ChartDateTimeAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_tickCount(0)
             {
             }
             ChartDateTimeAxisY::~ChartDateTimeAxisY()
             {
             }
             void ChartDateTimeAxisY::createLabels(QStringList &labels,qreal min, qreal max, int ticks)
             {
                 Q_ASSERT(max>min);
                 Q_ASSERT(ticks>1);
                 QDateTimeAxis *axis = qobject_cast<QDateTimeAxis *>(m_chartAxis);
                 int n = qMax(int(-floor(log10((max-min)/(ticks-1)))),0);
                 n++;
                 for (int i=0; i< ticks; i++) {
                     qreal value = min + (i * (max - min)/ (ticks-1));
                     labels << QDateTime::fromMSecsSinceEpoch(value).toString(axis->formatString());
                 }
             }
             QVector<qreal> ChartDateTimeAxisY::calculateLayout() const
             {
                 Q_ASSERT(m_tickCount>=2);
                 QVector<qreal> points;
                 points.resize(m_tickCount);
                 const qreal deltaY = m_rect.height()/(m_tickCount-1);
                 for (int i = 0; i < m_tickCount; ++i) {
                     int y = i * -deltaY + m_rect.bottom();
                     points[i] = y;
                 }
                 return points;
             }
             void ChartDateTimeAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList;
                 createLabels(ticksList,m_min,m_max,layout.size());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
                 qreal height =  2*m_rect.bottom();
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
                         if(labelItem->pos().y()+rect.height()>height) {
                             labelItem->setVisible(false);
                             lineItem->setVisible(false);
                         }
                         else {
                             labelItem->setVisible(true);
                             lineItem->setVisible(true);
                             height=labelItem->pos().y();
                         }
                         m_minWidth=qMax(rect.width()+label_padding,m_minWidth);
                         m_minHeight+=rect.height();
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
                         rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
                 }
             }
             void ChartDateTimeAxisY::handleAxisUpdated()
             {
                 //TODO:: fix this
                 QDateTimeAxis* axis = qobject_cast<QDateTimeAxis*>(m_chartAxis);
                 m_tickCount = axis->ticksCount();
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/intervalsaxis/chartintervalsaxisx.cpp +2 -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$
             **
             ****************************************************************************/
             #include "chartintervalsaxisx_p.h"
+            #include "qintervalsaxis.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
-            #include "chartanimator_p.h"
             #include <QGraphicsLayout>
-            #include <QDebug>
             #include <QFontMetrics>
-            #include <cmath>
+            #include <qmath.h>
-            #include <QIntervalsAxis>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartIntervalAxisX::ChartIntervalAxisX(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
             {
             }
             ChartIntervalAxisX::~ChartIntervalAxisX()
             {
             }
             QVector<qreal> ChartIntervalAxisX::calculateLayout() const
             {
                 QIntervalsAxis *axis = qobject_cast<QIntervalsAxis *>(m_chartAxis);
                 int tickCount = axis->intervalsLabels().count() + 1;
                 QVector<qreal> points;
                 if (tickCount < 2)
                     return points;
                 points.resize(tickCount);
                 qreal scale = m_rect.width() / axis->max();
                 for (int i = 0; i < tickCount; ++i)
                     if (i < tickCount - 1) {
                         int x = axis->intervalMin(axis->intervalsLabels().at(i)) * scale + m_rect.left();
                         points[i] = x;
                     } else {
                         int x = axis->intervalMax(axis->intervalsLabels().at(i - 1))  * scale + m_rect.left();
                         points[i] = x;
                     }
                 return points;
             }
             void ChartIntervalAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QIntervalsAxis *intervalAxis = qobject_cast<QIntervalsAxis *>(m_chartAxis);
                 QStringList ticksList = intervalAxis->intervalsLabels();
                 //    createNumberLabels(ticksList,m_min,m_max,layout.size());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 //    Q_ASSERT(labels.size() == ticksList.size());
                 //    Q_ASSERT(layout.size() == ticksList.size());
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
                 //    qreal width = 0;
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                     if (i < ticksList.count()) {
                         labelItem->setText(ticksList.at(i));
                     }
                     const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     if (i < ticksList.count())
                         labelItem->setPos(layout[i] + (layout[i + 1] - layout[i]) / 2 - center.x(), m_rect.bottom() + label_padding);
                     else
                         labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
                     if(labelItem->pos().x() > m_rect.width() + m_rect.left() - rect.width() / 2){
                         labelItem->setVisible(false);
                         lineItem->setVisible(false);
                     }
                     m_minWidth += rect.width();
                     m_minHeight = qMax(rect.height(), m_minHeight);
                     if ((i + 1) % 2 && i > 1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1));
                         rectItem->setRect(layout[i - 1],m_rect.top(),layout[i]-layout[i - 1],m_rect.height());
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(layout[i],m_rect.bottom(),layout[i], m_rect.bottom() + 5);
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/intervalsaxis/chartintervalsaxisy.cpp +3 -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$
             **
             ****************************************************************************/
             #include "chartintervalsaxisy_p.h"
+            #include "qintervalsaxis.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
-            #include "chartanimator_p.h"
             #include <QGraphicsLayout>
-            #include <QDebug>
             #include <QFontMetrics>
-            #include <cmath>
+            #include <qmath.h>
-            #include <QIntervalsAxis>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartIntervalAxisY::ChartIntervalAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
             {
             }
             ChartIntervalAxisY::~ChartIntervalAxisY()
             {
             }
             QVector<qreal> ChartIntervalAxisY::calculateLayout() const
             {
                 QIntervalsAxis *axis = qobject_cast<QIntervalsAxis *>(m_chartAxis);
                 int tickCount = axis->intervalsLabels().count() + 1;
                 QVector<qreal> points;
                 if (tickCount < 2)
                     return points;
                 points.resize(tickCount);
                 qreal scale = m_rect.height() / axis->max();
                 for (int i = 0; i < tickCount; ++i)
                     if (i < tickCount - 1) {
                         int y = -axis->intervalMin(axis->intervalsLabels().at(i)) * scale + m_rect.bottom();
                         points[i] = y;
                     } else {
                         int y = -axis->intervalMax(axis->intervalsLabels().at(i - 1))  * scale + m_rect.bottom();
                         points[i] = y;
                     }
                 return points;
             }
             void ChartIntervalAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QIntervalsAxis *intervalAxis = qobject_cast<QIntervalsAxis *>(m_chartAxis);
                 QStringList ticksList = intervalAxis->intervalsLabels();
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 //    Q_ASSERT(labels.size() == ticksList.size());
                 //    Q_ASSERT(layout.size() == ticksList.size());
                 qreal height =  2*m_rect.bottom();
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                     if (i < ticksList.count()) {
                         labelItem->setText(ticksList.at(i));
                     }
                     const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     if (i < ticksList.count())
                         labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i] + (layout[i + 1] - layout[i]) / 2 - center.y());
                     else
                         labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
                     if(labelItem->pos().y()+rect.height()>height) {
                         labelItem->setVisible(false);
                         lineItem->setVisible(false);
                     }
                     else {
                         labelItem->setVisible(true);
                         lineItem->setVisible(true);
                         height=labelItem->pos().y();
                     }
                     m_minWidth=qMax(rect.width()+label_padding,m_minWidth);
                     m_minHeight+=rect.height();
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
                         rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valuesaxis/chartvaluesaxisx.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 "chartvaluesaxisx_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
-            #include "chartanimator_p.h"
             #include "qvaluesaxis.h"
             #include <QGraphicsLayout>
-            #include <QDebug>
             #include <QFontMetrics>
-            #include <cmath>
+            #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartValuesAxisX::ChartValuesAxisX(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_tickCount(0)
             {
             }
             ChartValuesAxisX::~ChartValuesAxisX()
             {
             }
             QVector<qreal> ChartValuesAxisX::calculateLayout() const
             {
                 Q_ASSERT(m_tickCount>=2);
                 QVector<qreal> points;
                 points.resize(m_tickCount);
                 const qreal deltaX = m_rect.width()/(m_tickCount-1);
                 for (int i = 0; i < m_tickCount; ++i) {
                     int x = i * deltaX + m_rect.left();
                     points[i] = x;
                 }
                 return points;
             }
             void ChartValuesAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList;
                 createNumberLabels(ticksList,m_min,m_max,layout.size());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
                 qreal width = 0;
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
                         if(labelItem->pos().x()<=width){
                             labelItem->setVisible(false);
                             lineItem->setVisible(false);
                         }else{
                             labelItem->setVisible(true);
                             lineItem->setVisible(true);
                             width=rect.width()+labelItem->pos().x();
                         }
                         m_minWidth+=rect.width();
                         m_minHeight=qMax(rect.height(),m_minHeight);
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
                         rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
                 }
             }
             void ChartValuesAxisX::handleAxisUpdated()
             {
                 //TODO:: fix this
                 QValuesAxis* axis = qobject_cast<QValuesAxis*>(m_chartAxis);
                 m_tickCount = axis->ticksCount();
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valuesaxis/chartvaluesaxisy.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 "chartvaluesaxisy_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
-            #include "chartanimator_p.h"
             #include "qvaluesaxis.h"
             #include <QGraphicsLayout>
-            #include <QDebug>
             #include <QFontMetrics>
-            #include <cmath>
+            #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartValuesAxisY::ChartValuesAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_tickCount(0)
             {
             }
             ChartValuesAxisY::~ChartValuesAxisY()
             {
             }
             QVector<qreal> ChartValuesAxisY::calculateLayout() const
             {
                 Q_ASSERT(m_tickCount>=2);
                 QVector<qreal> points;
                 points.resize(m_tickCount);
                 const qreal deltaY = m_rect.height()/(m_tickCount-1);
                 for (int i = 0; i < m_tickCount; ++i) {
                     int y = i * -deltaY + m_rect.bottom();
                     points[i] = y;
                 }
                 return points;
             }
             void ChartValuesAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList;
                 createNumberLabels(ticksList,m_min,m_max,layout.size());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
                 qreal height =  2*m_rect.bottom();
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
                         if(labelItem->pos().y()+rect.height()>height) {
                             labelItem->setVisible(false);
                             lineItem->setVisible(false);
                         }
                         else {
                             labelItem->setVisible(true);
                             lineItem->setVisible(true);
                             height=labelItem->pos().y();
                         }
                         m_minWidth=qMax(rect.width()+label_padding,m_minWidth);
                         m_minHeight+=rect.height();
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
                         rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
                 }
             }
             void ChartValuesAxisY::handleAxisUpdated()
             {
                 //TODO:: fix this
                 QValuesAxis* axis = qobject_cast<QValuesAxis*>(m_chartAxis);
                 m_tickCount = axis->ticksCount();
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/abstractbarchartitem.cpp +1 -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 "abstractbarchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qabstractbarseries.h"
             #include "qabstractbarseries_p.h"
             #include "qchart.h"
             #include "chartpresenter_p.h"
-            #include "chartanimator_p.h"
+            #include "charttheme_p.h"
             #include "abstractbaranimation_p.h"
             #include "chartdataset_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AbstractBarChartItem::AbstractBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 ChartItem(presenter),
                 m_animation(0),
                 m_series(series)
             {
                 setFlag(ItemClipsChildrenToShape);
                 connect(series->d_func(), SIGNAL(updatedBars()), this, SLOT(handleLayoutChanged()));
                 connect(series->d_func(), SIGNAL(labelsVisibleChanged(bool)), this, SLOT(handleLabelsVisibleChanged(bool)));
                 connect(series->d_func(), SIGNAL(restructuredBars()), this, SLOT(handleDataStructureChanged()));
                 connect(series, SIGNAL(visibleChanged()), this, SLOT(handleVisibleChanged()));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 handleDataStructureChanged();
             }
             AbstractBarChartItem::~AbstractBarChartItem()
             {
             }
             void AbstractBarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             QRectF AbstractBarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void AbstractBarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (m_animation) {
                     m_animation->setup(m_layout,layout);
                     presenter()->startAnimation(m_animation);
                 } else {
                     setLayout(layout);
                     update();
                 }
             }
             void AbstractBarChartItem::setAnimation(AbstractBarAnimation *animation)
             {
                 m_animation = animation;
             }
             void AbstractBarChartItem::setLayout(const QVector<QRectF> &layout)
             {
                 if (layout.count() != m_bars.count())
                     return;
                 m_layout = layout;
                 for (int i=0; i < m_bars.count(); i++) {
                     m_bars.at(i)->setRect(layout.at(i));
                 }
             }
             //handlers
             void AbstractBarChartItem::handleDomainUpdated()
             {
                 m_domainMinX = domain()->minX();
                 m_domainMaxX = domain()->maxX();
                 m_domainMinY = domain()->minY();
                 m_domainMaxY = domain()->maxY();
                 handleLayoutChanged();
             }
             void AbstractBarChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 handleLayoutChanged();
             }
             void AbstractBarChartItem::handleLayoutChanged()
             {
                 if ((m_rect.width() <= 0) || (m_rect.height() <= 0)) {
                     // rect size zero.
                     return;
                 }
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
             }
             void AbstractBarChartItem::handleLabelsVisibleChanged(bool visible)
             {
                 foreach (QGraphicsSimpleTextItem* label, m_labels) {
                     label->setVisible(visible);
                 }
                 update();
             }
             void AbstractBarChartItem::handleDataStructureChanged()
             {
                 foreach(QGraphicsItem *item, childItems()) {
                     delete item;
                 }
                 m_bars.clear();
                 m_labels.clear();
                 m_layout.clear();
                 bool labelsVisible = m_series->isLabelsVisible();
                 // Create new graphic items for bars
                 for (int c = 0; c < m_series->d_func()->categoryCount(); c++) {
                     for (int s = 0; s < m_series->count(); s++) {
                         QBarSet *set = m_series->d_func()->barsetAt(s);
                         // Bars
                         Bar *bar = new Bar(set,c,this);
                         m_bars.append(bar);
                         connect(bar, SIGNAL(clicked(int, QBarSet*)), m_series, SIGNAL(clicked(int, QBarSet*)));
                         connect(bar, SIGNAL(hovered(bool, QBarSet*)), m_series, SIGNAL(hovered(bool, QBarSet*)));
                         connect(bar, SIGNAL(clicked(int, QBarSet*)), set, SIGNAL(clicked(int)));
                         connect(bar, SIGNAL(hovered(bool, QBarSet*)), set, SIGNAL(hovered(bool)));
                         m_layout.append(QRectF(0, 0, 0, 0));
                         // Labels
                         QGraphicsSimpleTextItem *label = new QGraphicsSimpleTextItem(this);
                         label->setVisible(labelsVisible);
                         m_labels.append(label);
                     }
                 }
                 // TODO: Is this the right place to call it?
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 handleLayoutChanged();
             }
             void AbstractBarChartItem::handleVisibleChanged()
             {
                 bool visible = m_series->isVisible();
                 handleLabelsVisibleChanged(visible);
                 foreach(QGraphicsItem *item, childItems()) {
                     item->setVisible(visible);
                 }
             }
             #include "moc_abstractbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/bar/qhorizontalbarseries.cpp 0 -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 "qhorizontalbarseries.h"
             #include "qhorizontalbarseries_p.h"
             #include "horizontalbarchartitem_p.h"
             #include "horizontalbaranimation_p.h"
             #include "qbarcategoriesaxis.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHorizontalBarSeries
                 \brief Series for creating horizontal bar chart
                 \mainclass
                 QHorizontalBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as groups, where bars in same category are grouped next to each other. QHorizontalBarSeries groups the data
                 from sets to categories, which are defined by a QStringList.
                 See the \l {HorizontalBarChart Example} {horizontal bar chart example} to learn how to create a horizontal bar chart.
                 \image examples_horizontalbarchart.png
                 \sa QBarSet, QBarSeries, QPercentBarSeries, QAbstractBarSeries, QStackedBarSeries, QHorizontalStackedBarSeries, QHorizontalPercentBarSeries
             */
             /*
                 // TODO:
                 \qmlclass Horizontal QHorizontalBarSeries
                 \inherits AbstractBarSeries
                 The following QML shows how to create a simple grouped bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View6.qml 1
                 \beginfloatleft
                 \image demos_qmlchart6.png
                 \endfloat
                 \clearfloat
             */
             QHorizontalBarSeries::QHorizontalBarSeries(QObject *parent) :
                 QAbstractBarSeries(*new QHorizontalBarSeriesPrivate(this), parent)
             {
             }
             QHorizontalBarSeries::~QHorizontalBarSeries()
             {
                 Q_D(QHorizontalBarSeries);
                 if(d->m_dataset) {
                     d->m_dataset->removeSeries(this);
                 }
             }
             QAbstractSeries::SeriesType QHorizontalBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeHorizontalBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QHorizontalBarSeriesPrivate::QHorizontalBarSeriesPrivate(QHorizontalBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QHorizontalBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 qreal y = categoryCount();
                 qreal x = max();
                 minX = qMin(minX, x);
                 minY = qMin(minY, - (qreal)0.5);
                 maxX = qMax(maxX, x);
                 maxY = qMax(maxY, y - (qreal)0.5);
                 domain.setRange(minX,maxX,minY,maxY);
             }
             Chart* QHorizontalBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QHorizontalBarSeries);
                 HorizontalBarChartItem* bar = new HorizontalBarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
-                    bar->setAnimator(presenter->animator());
                     bar->setAnimation(new HorizontalBarAnimation(bar));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qhorizontalbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/percent/qhorizontalpercentbarseries.cpp 0 -1

             #include "qhorizontalpercentbarseries.h"
             #include "qhorizontalpercentbarseries_p.h"
             #include "horizontalpercentbarchartitem_p.h"
             #include "horizontalpercentbaranimation_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QHorizontalPercentBarSeries::QHorizontalPercentBarSeries(QObject *parent) :
                 QAbstractBarSeries(*new QHorizontalPercentBarSeriesPrivate(this), parent)
             {
             }
             QAbstractSeries::SeriesType QHorizontalPercentBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeHorizontalPercentBar;
             }
             QHorizontalPercentBarSeries::~QHorizontalPercentBarSeries()
             {
                 Q_D(QHorizontalPercentBarSeries);
                 if(d->m_dataset) {
                     d->m_dataset->removeSeries(this);
                 }
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QHorizontalPercentBarSeriesPrivate::QHorizontalPercentBarSeriesPrivate(QHorizontalPercentBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QHorizontalPercentBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 qreal y = categoryCount();
                 minX = 0;
                 maxX = 100;
                 minY = qMin(minY, - (qreal)0.5);
                 maxY = qMax(maxY, y - (qreal)0.5);
                 domain.setRange(minX,maxX,minY,maxY);
             }
             Chart* QHorizontalPercentBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QHorizontalPercentBarSeries);
                 HorizontalPercentBarChartItem* bar = new HorizontalPercentBarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
-                    bar->setAnimator(presenter->animator());
                     bar->setAnimation(new HorizontalPercentBarAnimation(bar));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qhorizontalpercentbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/stacked/qhorizontalstackedbarseries.cpp 0 -1

             #include "qhorizontalstackedbarseries.h"
             #include "qhorizontalstackedbarseries_p.h"
             #include "horizontalstackedbarchartitem_p.h"
             #include "horizontalstackedbaranimation_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QHorizontalStackedBarSeries::QHorizontalStackedBarSeries(QObject *parent) :
                 QAbstractBarSeries(*new QHorizontalStackedBarSeriesPrivate(this), parent)
             {
             }
             QHorizontalStackedBarSeries::~QHorizontalStackedBarSeries()
             {
                 Q_D(QHorizontalStackedBarSeries);
                 if(d->m_dataset) {
                     d->m_dataset->removeSeries(this);
                 }
             }
             QAbstractSeries::SeriesType QHorizontalStackedBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeHorizontalStackedBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QHorizontalStackedBarSeriesPrivate::QHorizontalStackedBarSeriesPrivate(QHorizontalStackedBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QHorizontalStackedBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 qreal y = categoryCount();
                 qreal x = maxCategorySum();
                 minX = qMin(minX, x);
                 minY = qMin(minY, - (qreal)0.5);
                 maxX = qMax(maxX, x);
                 maxY = qMax(maxY, y - (qreal)0.5);
                 domain.setRange(minX,maxX,minY,maxY);
             }
             Chart* QHorizontalStackedBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QHorizontalStackedBarSeries);
                 HorizontalStackedBarChartItem* bar = new HorizontalStackedBarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
-                    bar->setAnimator(presenter->animator());
                     bar->setAnimation(new HorizontalStackedBarAnimation(bar));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qhorizontalstackedbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/bar/qbarseries.cpp 0 -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$
             **
             ****************************************************************************/
             #include "qbarseries.h"
             #include "qbarseries_p.h"
             #include "barchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
-            #include "chartanimator_p.h"
             #include "baranimation_p.h"
             #include "qvaluesaxis.h"
             #include "qbarcategoriesaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief Series for creating bar chart
                 \mainclass
                 QBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as groups, where bars in same category are grouped next to each other. QBarSeries groups the data
                 from sets to categories, which are defined by a QStringList.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a grouped bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QPercentBarSeries, QAbstractBarSeries, QStackedBarSeries
             */
             /*!
                 \qmlclass BarSeries QBarSeries
                 \inherits AbstractBarSeries
                 The following QML shows how to create a simple grouped bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View6.qml 1
                 \beginfloatleft
                 \image demos_qmlchart6.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QBarSeries.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypeBar.
             */
             QAbstractSeries::SeriesType QBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBar;
             }
             QBarSeries::~QBarSeries()
             {
                 Q_D(QBarSeries);
                 if(d->m_dataset) {
                     d->m_dataset->removeSeries(this);
                 }
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 qreal x = categoryCount();
                 qreal y = max();
                 minX = qMin(minX, - (qreal)0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, x - (qreal)0.5);
                 maxY = qMax(maxY, y);
                 domain.setRange(minX,maxX,minY,maxY);
             }
             Chart* QBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QBarSeries);
                 BarChartItem* bar = new BarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
-                    bar->setAnimator(presenter->animator());
                     bar->setAnimation(new BarAnimation(bar));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/percent/percentbarchartitem.cpp 0 -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 "percentbarchartitem_p.h"
             #include "bar_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
-            #include "chartanimator_p.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarChartItem::PercentBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 AbstractBarChartItem(series, presenter)
             {
             }
             QVector<QRectF> PercentBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal barWidth = scaleX * m_series->d_func()->barWidth();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal colSum = m_series->d_func()->categorySum(category);
                     qreal percentage = (100 / colSum);
                     qreal yPos = height + scaleY * m_domainMinY + geometry().topLeft().y();
                     for (int set=0; set < setCount; set++) {
                         QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->pos(category) - m_domainMinX) * scaleX + m_rect.left() - barWidth/2;
                         qreal barHeight = barSet->value(category) * percentage * scaleY;
                         Bar* bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         if (qFuzzyIsNull(barHeight)) {
                             bar->setVisible(false);
                         } else {
                             bar->setVisible(barsVisible);
                         }
                         QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(m_series->d_func()->valueAt(set,category))) {
                             int p = m_series->d_func()->percentageAt(set,category) * 100;
                             QString vString(QString::number(p));
                             vString.truncate(3);
                             vString.append("%");
                             label->setText(vString);
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                 }
                 return layout;
             }
             #include "moc_percentbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/percent/qpercentbarseries.cpp 0 -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$
             **
             ****************************************************************************/
             #include "qpercentbarseries.h"
             #include "qpercentbarseries_p.h"
             #include "percentbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
-            #include "chartanimator_p.h"
             #include "qvaluesaxis.h"
             #include "percentbaranimation_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPercentBarSeries
                 \brief Series for creating percent bar chart
                 \mainclass
                 QPercentBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as stacks, where each bar is shown as percentage of all bars in that category.
                 QPercentBarSeries groups the data from sets to categories, which are defined by a QStringList.
                 See the \l {PercentbarChart Example} {percent bar chart example} to learn how to create a percent bar chart.
                 \image examples_percentbarchart.png
                 \sa QBarSet, QStackedBarSeries, QAbstractBarSeries
             */
             /*!
                 \qmlclass PercentBarSeries QPercentBarSeries
                 \inherits QAbstractBarSeries
                 The following QML shows how to create a simple percent bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View8.qml 1
                 \beginfloatleft
                 \image demos_qmlchart8.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QPercentBarSeries.
                 QPercentBarSeries is QObject which is a child of a \a parent.
             */
             QPercentBarSeries::QPercentBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QPercentBarSeriesPrivate(this), parent)
             {
             }
             QPercentBarSeries::~QPercentBarSeries()
             {
                 Q_D(QPercentBarSeries);
                 if(d->m_dataset) {
                     d->m_dataset->removeSeries(this);
                 }
             }
             /*!
                 Returns QChartSeries::SeriesTypePercentBar.
             */
             QAbstractSeries::SeriesType QPercentBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePercentBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPercentBarSeriesPrivate::QPercentBarSeriesPrivate(QPercentBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QPercentBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 qreal x = categoryCount();
                 minX = qMin(minX, - (qreal)0.5);
                 maxX = qMax(maxX, x - (qreal)0.5);
                 minY = 0;
                 maxY = 100;
                 domain.setRange(minX,maxX,minY,maxY);
             }
             Chart* QPercentBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QPercentBarSeries);
                 PercentBarChartItem* bar = new PercentBarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
-                    bar->setAnimator(presenter->animator());
                     bar->setAnimation(new PercentBarAnimation(bar));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qpercentbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/stacked/qstackedbarseries.cpp 0 -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$
             **
             ****************************************************************************/
             #include "qstackedbarseries.h"
             #include "qstackedbarseries_p.h"
             #include "stackedbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
-            #include "chartanimator_p.h"
             #include "qvaluesaxis.h"
             #include "stackedbaranimation_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QStackedBarSeries
                 \brief Series for creating stacked bar chart
                 \mainclass
                 QStackedBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as stacks, where bars in same category are stacked on top of each other.
                 QStackedBarSeries groups the data from sets to categories, which are defined by QStringList.
                 See the \l {StackedbarChart Example} {stacked bar chart example} to learn how to create a stacked bar chart.
                 \image examples_stackedbarchart.png
                 \sa QBarSet, QPercentBarSeries, QAbstractBarSeries
             */
             /*!
                 \qmlclass StackedBarSeries QStackedBarSeries
                 \inherits AbstractBarSeries
                 The following QML shows how to create a simple stacked bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View7.qml 1
                 \beginfloatleft
                 \image demos_qmlchart7.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QStackedBarSeries.
                 QStackedBarSeries is QObject which is a child of a \a parent.
             */
             QStackedBarSeries::QStackedBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QStackedBarSeriesPrivate(this), parent)
             {
             }
             QStackedBarSeries::~QStackedBarSeries()
             {
                 Q_D(QStackedBarSeries);
                 if(d->m_dataset) {
                     d->m_dataset->removeSeries(this);
                 }
             }
             /*!
                 Returns QChartSeries::SeriesTypeStackedBar.
             */
             QAbstractSeries::SeriesType QStackedBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeStackedBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QStackedBarSeriesPrivate::QStackedBarSeriesPrivate(QStackedBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QStackedBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 qreal x = categoryCount();
                 qreal y = maxCategorySum();
                 minX = qMin(minX, - (qreal)0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, x - (qreal)0.5);
                 maxY = qMax(maxY, y);
                 domain.setRange(minX,maxX,minY,maxY);
             }
             Chart* QStackedBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QStackedBarSeries);
                 StackedBarChartItem* bar = new StackedBarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
-                    bar->setAnimator(presenter->animator());
                     bar->setAnimation(new StackedBarAnimation(bar));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qstackedbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/stacked/stackedbarchartitem.cpp 0 -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 "stackedbarchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
-            #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             StackedBarChartItem::StackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 AbstractBarChartItem(series, presenter)
             {
             }
             QVector<QRectF> StackedBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal barWidth = scaleX * m_series->d_func()->barWidth();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal yPos = height + rangeY * m_domainMinY + geometry().topLeft().y();
                     for (int set=0; set < setCount; set++) {
                         QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->pos(category) - m_domainMinX) * scaleX + m_rect.left() - barWidth/2;
                         qreal barHeight = barSet->value(category) * scaleY;
                         Bar* bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         if (qFuzzyIsNull(barHeight)) {
                             bar->setVisible(false);
                         } else {
                             bar->setVisible(barsVisible);
                         }
                         QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(barSet->value(category))) {
                             label->setText(QString::number(barSet->value(category)));
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                 }
                 return layout;
             }
             #include "moc_stackedbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chart.cpp 0 -12

             /****************************************************************************
             **
             ** 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 "chart_p.h"
             #include "chartpresenter_p.h"
             #include "domain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Chart::Chart(ChartPresenter *presenter):QObject(presenter),
-                m_animator(0),
                 m_presenter(presenter),
                 m_domain(0)
             {
             }
-            void Chart::setAnimator(ChartAnimator* animator)
-                m_animator=animator;
-            ChartAnimator* Chart::animator() const
-                return m_animator;
             void Chart::setPresenter(ChartPresenter *presenter)
             {
                 m_presenter=presenter;
             }
             ChartPresenter* Chart::presenter() const
             {
                 return m_presenter;
             }
             void Chart::setDomain(Domain *domain)
             {
                 m_domain=domain;
             }
             Domain* Chart::domain() const
             {
                 return m_domain;
             }
             void Chart::handleGeometryChanged(const QRectF& rect)
             {
                 Q_UNUSED(rect);
                 qWarning()<<"Slot not implemented";
             }
             void Chart::handleDomainChanged(qreal minX,qreal maxX,qreal minY,qreal maxY)
             {
                 Q_UNUSED(minX);
                 Q_UNUSED(maxX);
                 Q_UNUSED(minY);
                 Q_UNUSED(maxY);
                 qWarning()<<"Slot not implemented";
             }
             void Chart::handleDomainUpdated()
             {
                 qWarning()<<"Slot not implemented";
             }
             #include "moc_chart_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chart_p.h +2 -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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHART_H
             #define CHART_H
             #include "qchartglobal.h"
             #include <QObject>
             #include <QRect>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartAnimator;
             class ChartPresenter;
             class ChartAnimation;
             class Domain;
             class Chart: public QObject
             {
                 Q_OBJECT
             public:
                 explicit Chart(ChartPresenter *presenter);
             public Q_SLOTS:
                 virtual void handleGeometryChanged(const QRectF& rect);
                 virtual void handleDomainChanged(qreal minX,qreal maxX,qreal minY,qreal maxY);
                 virtual void handleDomainUpdated();
+                virtual ChartAnimation* animation() const { return 0; };
-                void setAnimator(ChartAnimator* animator);
-                ChartAnimator* animator() const;
                 void setPresenter(ChartPresenter *presenter);
                 ChartPresenter* presenter() const;
                 void setDomain(Domain *domain);
                 Domain* domain() const;
-                virtual ChartAnimation* animation() const { return 0; };
             private:
-                ChartAnimator* m_animator;
                 ChartPresenter* m_presenter;
                 Domain* m_domain;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/chartpresenter.cpp 0 -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$
              **
              ****************************************************************************/
             #include "chartpresenter_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
-            #include "chartanimator_p.h"
             #include "chartanimation_p.h"
             #include "qabstractseries_p.h"
             #include "qareaseries.h"
             #include "chartaxis_p.h"
             //#include "chartaxisx_p.h"
             //#include "chartaxisy_p.h"
             #include "areachartitem_p.h"
             #include "chartbackground_p.h"
             #include "chartlayout_p.h"
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
-            m_animator(0),
             m_dataset(dataset),
             m_chartTheme(0),
             m_options(QChart::NoAnimation),
             m_state(ShowState),
             m_layout(new ChartLayout(this)),
             m_backgroundItem(0),
             m_titleItem(0)
             {
             }
             ChartPresenter::~ChartPresenter()
             {
                 delete m_chartTheme;
             }
             void ChartPresenter::setGeometry(const QRectF& rect)
             {
                 Q_ASSERT(rect.isValid());
                 if(m_rect!=rect) {
                        m_rect=rect;
                        emit geometryChanged(m_rect);
                 }
             }
             void ChartPresenter::handleAxisAdded(QAbstractAxis* axis,Domain* domain)
             {
                 ChartAxis* item = axis->d_ptr->createGraphics(this);
                 item->setDomain(domain);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
-                    item->setAnimator(m_animator);
                     item->setAnimation(new AxisAnimation(item));
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
                 QObject::connect(domain,SIGNAL(updated()),item,SLOT(handleDomainUpdated()));
                 QObject::connect(axis,SIGNAL(visibleChanged(bool)),this,SLOT(handleAxisVisibleChanged(bool)));
                 //initialize
                 domain->emitUpdated();
                 m_chartTheme->decorate(axis);
                 axis->d_ptr->setDirty(false);
                 axis->d_ptr->emitUpdated();
                 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                 m_axisItems.insert(axis, item);
                 selectVisibleAxis();
             }
             void ChartPresenter::handleAxisRemoved(QAbstractAxis* axis)
             {
                 ChartAxis* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 selectVisibleAxis();
-                if(m_animator) m_animator->removeAnimation(item);
                 item->hide();
                 item->disconnect();
                 QObject::disconnect(this,0,item,0);
                 item->deleteLater();
             }
             void ChartPresenter::handleSeriesAdded(QAbstractSeries* series,Domain* domain)
             {
                 Chart *item = series->d_ptr->createGraphics(this);
                 Q_ASSERT(item);
                 item->setDomain(domain);
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
                 QObject::connect(domain,SIGNAL(updated()),item,SLOT(handleDomainUpdated()));
                 //initialize
                 item->handleDomainUpdated();
                 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                 m_chartItems.insert(series,item);
             }
             void ChartPresenter::handleSeriesRemoved(QAbstractSeries* series)
             {
                 Chart* item = m_chartItems.take(series);
                 Q_ASSERT(item);
-                if(m_animator) {
-                    //small hack to handle area animations
-                    if(series->type() == QAbstractSeries::SeriesTypeArea){
-                        QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
-                        AreaChartItem* area = static_cast<AreaChartItem*>(item);
-                        m_animator->removeAnimation(area->upperLineItem());
-                        if(areaSeries->lowerSeries())  m_animator->removeAnimation(area->lowerLineItem());
-                    }else
-                        m_animator->removeAnimation(item);
                 item->deleteLater();
             }
             void ChartPresenter::selectVisibleAxis()
             {
                 QMapIterator<QAbstractAxis*, ChartAxis*> i(m_axisItems);
                 while (i.hasNext()) {
                     i.next();
                     i.key()->hide();
                 }
                 i.toFront();
                 bool axisX=false;
                 bool axisY=false;
                 while (i.hasNext()) {
                     i.next();
                     if(i.key()->orientation()==Qt::Vertical && !axisY) {
                         axisY=true;
                         i.key()->show();
                     }
                     if(i.key()->orientation()==Qt::Horizontal && !axisX) {
                         axisX=true;
                         i.key()->show();
                     }
                 }
             }
             void ChartPresenter::handleAxisVisibleChanged(bool visible)
             {
                 QAbstractAxis* axis = static_cast<QAbstractAxis*> (sender());
                 Q_ASSERT(axis);
                 if(visible){
                     QMapIterator<QAbstractAxis*, ChartAxis*> i(m_axisItems);
                     while (i.hasNext()) {
                     i.next();
                     if(i.key()==axis) {
                         continue;
                     }
                     if(i.key()->orientation()==axis->orientation()) {
                         i.key()->setVisible(false);
                     }
                     }
                 }
             }
             void ChartPresenter::setTheme(QChart::ChartTheme theme,bool force)
             {
                 if(m_chartTheme && m_chartTheme->id() == theme) return;
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->setForced(force);
                 m_chartTheme->decorate(m_chart);
                 m_chartTheme->decorate(m_chart->legend());
                 resetAllElements();
                 // We do not want "force" to stay on.
                 // Bar/pie are calling decorate when adding/removing slices/bars which means
                 // that to preserve users colors "force" must not be on.
                 m_chartTheme->setForced(false);
             }
             QChart::ChartTheme ChartPresenter::theme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
-                    if(m_options!=QChart::NoAnimation && !m_animator) {
-                        m_animator= new ChartAnimator(this);
                     resetAllElements();
                 }
             }
             void ChartPresenter::resetAllElements()
             {
                 QMapIterator<QAbstractAxis*, ChartAxis*> i(m_axisItems);
                 while (i.hasNext()) {
                        i.next();
                        Domain* domain = i.value()->domain();
                        QAbstractAxis* axis = i.key();
                        handleAxisRemoved(axis);
                        handleAxisAdded(axis,domain);
                 }
                 QMapIterator<QAbstractSeries*, Chart*> j(m_chartItems);
                    while (j.hasNext()) {
                           j.next();
                           Domain* domain = j.value()->domain();
                           QAbstractSeries* series = j.key();
                           handleSeriesRemoved(series);
                           handleSeriesAdded(series,domain);
                    }
             }
             void ChartPresenter::zoomIn(qreal factor)
             {
                 QRectF rect = geometry();
                 rect.setWidth(rect.width()/factor);
                 rect.setHeight(rect.height()/factor);
                 rect.moveCenter(geometry().center());
                 zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
                 QRectF r = rect.normalized();
                 r.translate(-geometry().topLeft());
                 if (!r.isValid())
                     return;
                 m_state = ZoomInState;
                 m_statePoint = QPointF(r.center().x()/geometry().width(),r.center().y()/geometry().height());
                 m_dataset->zoomInDomain(r,geometry().size());
                 m_state = ShowState;
             }
             void ChartPresenter::zoomOut(qreal factor)
             {
                 m_state = ZoomOutState;
                 QRectF chartRect;
                 chartRect.setSize(geometry().size());
                 QRectF rect;
                 rect.setSize(chartRect.size()/factor);
                 rect.moveCenter(chartRect.center());
                 if (!rect.isValid())
                     return;
                 m_statePoint = QPointF(rect.center().x()/geometry().width(),rect.center().y()/geometry().height());
                 m_dataset->zoomOutDomain(rect, chartRect.size());
                 m_state = ShowState;
             }
             void ChartPresenter::scroll(qreal dx,qreal dy)
             {
                 if(dx<0) m_state=ScrollLeftState;
                 if(dx>0) m_state=ScrollRightState;
                 if(dy<0) m_state=ScrollUpState;
                 if(dy>0) m_state=ScrollDownState;
                 m_dataset->scrollDomain(dx,dy,geometry().size());
                 m_state = ShowState;
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::createBackgroundItem()
             {
                 if (!m_backgroundItem) {
                     m_backgroundItem = new ChartBackground(rootItem());
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createTitleItem()
             {
                 if (!m_titleItem) {
                     m_titleItem = new QGraphicsSimpleTextItem(rootItem());
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::handleAnimationFinished()
             {
                m_animations.removeAll(qobject_cast<ChartAnimation*>(sender()));
                if(m_animations.empty()) emit animationsFinished();
             }
             void ChartPresenter::startAnimation(ChartAnimation* animation)
             {
                 if (animation->state() != QAbstractAnimation::Stopped) animation->stop();
                 QObject::connect(animation, SIGNAL(finished()),this,SLOT(handleAnimationFinished()),Qt::UniqueConnection);
                 if(!m_animations.isEmpty()){
                     m_animations.append(animation);
                 }
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             QGraphicsRectItem* ChartPresenter::backgroundItem()
             {
                 return m_backgroundItem;
             }
             void ChartPresenter::setBackgroundBrush(const QBrush& brush)
             {
                 createBackgroundItem();
                 m_backgroundItem->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::backgroundBrush() const
             {
                 if (!m_backgroundItem) return QBrush();
                 return m_backgroundItem->brush();
             }
             void ChartPresenter::setBackgroundPen(const QPen& pen)
             {
                 createBackgroundItem();
                 m_backgroundItem->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::backgroundPen() const
             {
                 if (!m_backgroundItem) return QPen();
                 return m_backgroundItem->pen();
             }
             QGraphicsItem* ChartPresenter::titleItem()
             {
                 return m_titleItem;
             }
             void ChartPresenter::setTitle(const QString& title)
             {
                 createTitleItem();
                 m_titleItem->setText(title);
                 m_layout->invalidate();
             }
             QString ChartPresenter::title() const
             {
                 if (!m_titleItem) return QString();
                 return m_titleItem->text();
             }
             void ChartPresenter::setTitleFont(const QFont& font)
             {
                 createTitleItem();
                 m_titleItem->setFont(font);
                 m_layout->invalidate();
             }
             QFont ChartPresenter::titleFont() const
             {
                 if (!m_titleItem)  return QFont();
                 return m_titleItem->font();
             }
             void ChartPresenter::setTitleBrush(const QBrush &brush)
             {
                 createTitleItem();
                 m_titleItem->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::titleBrush() const
             {
                 if (!m_titleItem) return QBrush();
                 return m_titleItem->brush();
             }
             void ChartPresenter::setBackgroundVisible(bool visible)
             {
                 createBackgroundItem();
                 m_backgroundItem->setVisible(visible);
             }
             bool ChartPresenter::isBackgroundVisible() const
             {
                 if (!m_backgroundItem) return false;
                 return m_backgroundItem->isVisible();
             }
             void ChartPresenter::setBackgroundDropShadowEnabled(bool enabled)
             {
                 createBackgroundItem();
                 m_backgroundItem->setDropShadowEnabled(enabled);
             }
             bool ChartPresenter::isBackgroundDropShadowEnabled() const
             {
                 if (!m_backgroundItem) return false;
                 return m_backgroundItem->isDropShadowEnabled();
             }
             QGraphicsLayout* ChartPresenter::layout()
             {
                 return m_layout;
             }
             void ChartPresenter::setMarginsMinimum(const QRectF& margins)
             {
                 Q_UNUSED(margins);
               //  m_layout->setMarginsMinimum(margins);
             }
             QRectF ChartPresenter::margins() const
             {
                 return m_layout->margins();
             }
             QLegend* ChartPresenter::legend()
             {
                 return m_chart->legend();
             }
             QList<ChartAxis*>  ChartPresenter::axisItems() const
             {
                 return m_axisItems.values();
             }
             void ChartPresenter::setVisible(bool visible)
             {
                 m_chart->setVisible(visible);
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h 0 -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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTPRESENTER_H
             #define CHARTPRESENTER_H
             #include "qchartglobal.h"
             #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
             #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Chart;
             class QAbstractSeries;
             class ChartDataSet;
             class Domain;
             class ChartAxis;
             class ChartTheme;
             class ChartAnimator;
             class ChartBackground;
             class ChartAnimation;
             class ChartLayout;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     ShadesZValue,
                     GridZValue,
                     SeriesZValue,
                     LineChartZValue = SeriesZValue,
                     BarSeriesZValue = SeriesZValue,
                     ScatterSeriesZValue = SeriesZValue,
                     PieSeriesZValue = SeriesZValue,
                     AxisZValue,
                     LegendZValue
                 };
                 enum State {
                     ShowState,
                     ScrollUpState,
                     ScrollDownState,
                     ScrollLeftState,
                     ScrollRightState,
                     ZoomInState,
                     ZoomOutState
                 };
                 ChartPresenter(QChart* chart,ChartDataSet *dataset);
                 virtual ~ChartPresenter();
-                ChartAnimator* animator() const { return m_animator; }
                 ChartTheme *chartTheme() const { return m_chartTheme; }
                 ChartDataSet *dataSet() const { return m_dataset; }
                 QGraphicsItem* rootItem() const { return m_chart; }
                 QGraphicsRectItem* backgroundItem();
                 QGraphicsItem* titleItem();
                 QList<ChartAxis*> axisItems() const;
                 QLegend* legend();
                 void setBackgroundBrush(const QBrush& brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen& pen);
                 QPen backgroundPen() const;
                 void setTitle(const QString& title);
                 QString title() const;
                 void setTitleFont(const QFont& font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundVisible(bool visible);
                 bool isBackgroundVisible() const;
                 void setBackgroundDropShadowEnabled(bool enabled);
                 bool isBackgroundDropShadowEnabled() const;
                 void setVisible(bool visible);
                 void setTheme(QChart::ChartTheme theme,bool force = true);
                 QChart::ChartTheme theme();
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void zoomIn(qreal factor);
                 void zoomIn(const QRectF& rect);
                 void zoomOut(qreal factor);
                 void scroll(qreal dx,qreal dy);
                 void setGeometry(const QRectF& rect);
                 QRectF geometry() { return m_rect; }
                 void startAnimation(ChartAnimation* animation);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
                 void resetAllElements();
                 void setMarginsMinimum(const QRectF& margins);
                 QRectF margins() const;
                 QGraphicsLayout* layout();
             private:
                 void createBackgroundItem();
                 void createTitleItem();
                 void selectVisibleAxis();
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries* series,Domain* domain);
                 void handleSeriesRemoved(QAbstractSeries* series);
                 void handleAxisAdded(QAbstractAxis* axis,Domain* domain);
                 void handleAxisRemoved(QAbstractAxis* axis);
                 void handleAxisVisibleChanged(bool visible);
             private Q_SLOTS:
                 void handleAnimationFinished();
             Q_SIGNALS:
                 void geometryChanged(const QRectF& rect);
                 void animationsFinished();
                 void marginsChanged(QRectF margins);
             private:
                 QChart* m_chart;
-                ChartAnimator* m_animator;
                 ChartDataSet* m_dataset;
                 ChartTheme *m_chartTheme;
                 QMap<QAbstractSeries*, Chart*> m_chartItems;
                 QMap<QAbstractAxis*, ChartAxis*> m_axisItems;
                 QRectF m_rect;
                 QChart::AnimationOptions m_options;
                 State m_state;
                 QPointF m_statePoint;
                 QList<ChartAnimation*> m_animations;
                 ChartLayout* m_layout;
                 ChartBackground* m_backgroundItem;
                 QGraphicsSimpleTextItem* m_titleItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

src/linechart/qlineseries.cpp 0 -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$
             **
             ****************************************************************************/
             #include "qlineseries.h"
             #include "qlineseries_p.h"
             #include "linechartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
-            #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLineSeries
                 \brief The QLineSeries class is used for making line charts.
                 \mainclass
             	A line chart is used to show information as a series of data points
             	connected by straight lines.
                 \image examples_linechart.png
             	Creating basic line chart is simple:
             	\code
                 QLineSeries* series = new QLineSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chart->addSeries(series);
                 \endcode
             */
             /*!
                 \qmlclass LineSeries QLineSeries
                 \inherits XYSeries
                 The following QML shows how to create a simple line chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View2.qml 1
                 \beginfloatleft
                 \image demos_qmlchart2.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \fn virtual SeriesType QLineSeries::type() const
                 \brief Returns type of series.
                 \sa QAbstractSeries, SeriesType
             */
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QLineSeries::QLineSeries(QObject *parent) : QXYSeries(*new QLineSeriesPrivate(this),parent)
             {
             }
             /*!
                 \internal
             */
             QLineSeries::QLineSeries(QLineSeriesPrivate &d,QObject *parent) : QXYSeries (d,parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QLineSeries::~QLineSeries()
             {
                 Q_D(QLineSeries);
                 if(d->m_dataset){
                        d->m_dataset->removeSeries(this);
                 }
             }
             QAbstractSeries::SeriesType QLineSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeLine;
             }
             /*
             QDebug operator<< (QDebug debug, const QLineSeries series)
             {
                 Q_ASSERT(series.d_func()->m_x.size() == series.d_func()->m_y.size());
                 int size = series.d_func()->m_x.size();
                 for (int i=0; i<size; i++) {
                     debug.nospace() << "(" << series.d_func()->m_x.at(i) << ','<< series.d_func()->m_y.at(i) << ") ";
                 }
                 return debug.space();
             }
             */
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLineSeriesPrivate::QLineSeriesPrivate(QLineSeries* q):QXYSeriesPrivate(q)
             {
             };
             Chart* QLineSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QLineSeries);
                 LineChartItem* line = new LineChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
-                    line->setAnimator(presenter->animator());
                     line->setAnimation(new XYAnimation(line));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return line;
             }
             #include "moc_qlineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechartitem.cpp +22 -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 "piechartitem_p.h"
             #include "piesliceitem_p.h"
             #include "qpieslice.h"
             #include "qpieslice_p.h"
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
-            #include "chartanimator_p.h"
+            #include "pieanimation_p.h"
             #include <QPainter>
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter* presenter)
                 :ChartItem(presenter),
-                m_series(series)
+                m_series(series),
+                m_animation(0)
             {
                 Q_ASSERT(series);
                 QPieSeriesPrivate *p = QPieSeriesPrivate::fromSeries(series);
                 connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 connect(series, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
                 connect(series, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
                 connect(p, SIGNAL(horizontalPositionChanged()), this, SLOT(updateLayout()));
                 connect(p, SIGNAL(verticalPositionChanged()), this, SLOT(updateLayout()));
                 connect(p, SIGNAL(pieSizeChanged()), this, SLOT(updateLayout()));
                 connect(p, SIGNAL(calculatedDataChanged()), this, SLOT(updateLayout()));
                 // Note: the following does not affect as long as the item does not have anything to paint
                 setZValue(ChartPresenter::PieSeriesZValue);
                 // Note: will not create slice items until we have a proper rectangle to draw on.
             }
             PieChartItem::~PieChartItem()
             {
                 // slices deleted automatically through QGraphicsItem
             }
+            void PieChartItem::setAnimation(PieAnimation* animation)
+            {
+                m_animation=animation;
+            }
+            ChartAnimation* PieChartItem::animation() const
+            {
+                return m_animation;
+            }
             void PieChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 updateLayout();
                 // This is for delayed initialization of the slice items during startup.
                 // It ensures that startup animation originates from the correct position.
                 if (m_sliceItems.isEmpty())
                     handleSlicesAdded(m_series->slices());
             }
             void PieChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 Q_UNUSED(minX);
                 Q_UNUSED(maxX);
                 Q_UNUSED(minY);
                 Q_UNUSED(maxY);
                 // does not apply to pie
             }
             void PieChartItem::rangeXChanged(qreal min, qreal max, int tickXCount)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 Q_UNUSED(tickXCount);
                 // does not apply to pie
             }
             void PieChartItem::rangeYChanged(qreal min, qreal max, int tickYCount)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 Q_UNUSED(tickYCount);
                 // does not apply to pie
             }
             void PieChartItem::updateLayout()
             {
                 // 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;
                 m_donutInnerRadius = m_pieRadius;
                 // apply size factor
                 m_pieRadius *= m_series->pieSize();
                 m_donutInnerRadius *= m_series->donutInnerSize();
                 // 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())
+                        if (m_animation){
-                            animator()->updateAnimation(this, sliceItem, sliceData);
+                            presenter()->startAnimation(m_animation->updateValue(sliceItem, sliceData));
+                        }
                         else
                             sliceItem->setLayout(sliceData);
                     }
                 }
                 update();
             }
             void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
             {
                 // delay creating slice items until there is a proper rectangle
                 if (!m_rect.isValid() && m_sliceItems.isEmpty())
                     return;
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 bool startupAnimation = m_sliceItems.isEmpty();
                 foreach (QPieSlice *slice, slices) {
                     PieSliceItem* sliceItem = new PieSliceItem(this);
                     m_sliceItems.insert(slice, sliceItem);
                     // Note: no need to connect to slice valueChanged() etc.
                     // This is handled through calculatedDataChanged signal.
                     connect(slice, SIGNAL(labelChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelVisibleChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(penChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(brushChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelBrushChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelFontChanged()), this, SLOT(handleSliceChanged()));
                     QPieSlicePrivate *p = QPieSlicePrivate::fromSlice(slice);
                     connect(p, SIGNAL(labelPositionChanged()), this, SLOT(handleSliceChanged()));
                     connect(p, SIGNAL(explodedChanged()), this, SLOT(handleSliceChanged()));
                     connect(p, SIGNAL(labelArmLengthFactorChanged()), this, SLOT(handleSliceChanged()));
                     connect(p, SIGNAL(explodeDistanceFactorChanged()), 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())
+                    if (m_animation)
-                        animator()->addAnimation(this, sliceItem, sliceData, startupAnimation);
+                        presenter()->startAnimation(m_animation->addSlice(sliceItem, sliceData, startupAnimation));
                     else
                         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);
                     // this can happen if you call append() & remove() in a row so that PieSliceItem is not even created
                     if (!sliceItem)
                         continue;
                     m_sliceItems.remove(slice);
-                    if (animator())
+                    if (m_animation)
-                        animator()->removeAnimation(this, sliceItem); // animator deletes the PieSliceItem
+                        presenter()->startAnimation(m_animation->removeSlice(sliceItem)); // animator deletes the PieSliceItem
                     else
                         delete sliceItem;
                 }
             }
             void PieChartItem::handleSliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 if (!slice) {
                     QPieSlicePrivate* slicep = qobject_cast<QPieSlicePrivate *>(sender());
                     slice = slicep->q_ptr;
                 }
                 Q_ASSERT(m_sliceItems.contains(slice));
                 PieSliceItem *sliceItem = m_sliceItems.value(slice);
                 PieSliceData sliceData = updateSliceGeometry(slice);
-                if (animator())
+                if (m_animation)
-                    animator()->updateAnimation(this, sliceItem, sliceData);
+                    presenter()->startAnimation(m_animation->updateValue(sliceItem, sliceData));
                 else
                     sliceItem->setLayout(sliceData);
                 update();
             }
             void PieChartItem::handleSeriesVisibleChanged()
             {
                 setVisible(m_series->isVisible());
             }
             PieSliceData PieChartItem::updateSliceGeometry(QPieSlice *slice)
             {
                 PieSliceData &sliceData = QPieSlicePrivate::fromSlice(slice)->m_data;
                 sliceData.m_center = PieSliceItem::sliceCenter(m_pieCenter, m_pieRadius, slice);
                 sliceData.m_radius = m_pieRadius;
                 sliceData.m_donut = m_series->donut();
                 sliceData.m_innerRadius = m_donutInnerRadius;
                 return sliceData;
             }
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechartitem_p.h +6 0

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #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;
+            class PieAnimation;
             class PieChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
                 explicit PieChartItem(QPieSeries *series, ChartPresenter *presenter);
                 ~PieChartItem();
                 // from QGraphicsItem
                 QRectF boundingRect() const { return m_rect; }
                 void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *) {}
             public Q_SLOTS:
                 // from Chart
                 virtual void handleGeometryChanged(const QRectF &rect);
                 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 updateLayout();
                 void handleSlicesAdded(QList<QPieSlice*> slices);
                 void handleSlicesRemoved(QList<QPieSlice*> slices);
                 void handleSliceChanged();
                 void handleSeriesVisibleChanged();
+                void setAnimation(PieAnimation* animation);
+                ChartAnimation* animation() const;
             private:
                 PieSliceData updateSliceGeometry(QPieSlice *slice);
             private:
                 QHash<QPieSlice*, PieSliceItem*> m_sliceItems;
                 QPieSeries *m_series;
                 QRectF m_rect;
                 QPointF m_pieCenter;
                 qreal m_pieRadius;
                 qreal m_donutInnerRadius;
+                PieAnimation* m_animation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIECHARTITEM_H

src/piechart/qpieseries.cpp +2 -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$
             **
             ****************************************************************************/
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "qpieslice_p.h"
             #include "pieslicedata_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
-            #include "chartanimator_p.h"
             #include "legendmarker_p.h"
             #include "qabstractaxis.h"
+            #include "pieanimation_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are defined as QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 Pie size and position on the chart is controlled by using relative values which range from 0.0 to 1.0
                 These relate to the actual chart rectangle.
                 By default the pie is defined as a full pie but it can also be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 Full pie is 360 degrees where 0 is at 12 a'clock.
                 See the \l {PieChart Example} {pie chart example} to learn how to create a simple pie chart.
                 \image examples_piechart.png
             */
             /*!
                 \qmlclass PieSeries QPieSeries
                 \inherits AbstractSeries
                 The following QML shows how to create a simple pie chart.
                 \snippet ../demos/qmlchart/qml/qmlchart/View1.qml 1
                 \beginfloatleft
                 \image demos_qmlchart1.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \property QPieSeries::horizontalPosition
                 \brief Defines the horizontal position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute left.
                 \o 1.0 is the absolute right.
                 \endlist
                 Default value is 0.5 (center).
                 \sa verticalPosition
             */
             /*!
                 \qmlproperty real PieSeries::horizontalPosition
                 Defines the horizontal position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute left.
                 \o 1.0 is the absolute right.
                 \endlist
                 Default value is 0.5 (center).
                 \sa verticalPosition
             */
             /*!
                 \property QPieSeries::verticalPosition
                 \brief Defines the vertical position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute top.
                 \o 1.0 is the absolute bottom.
                 \endlist
                 Default value is 0.5 (center).
                 \sa horizontalPosition
             */
             /*!
                 \qmlproperty real PieSeries::verticalPosition
                 Defines the vertical position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute top.
                 \o 1.0 is the absolute bottom.
                 \endlist
                 Default value is 0.5 (center).
                 \sa horizontalPosition
             */
             /*!
                 \property QPieSeries::size
                 \brief Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (pie not drawn).
                 \o 1.0 is the maximum size that can fit the chart.
                 \endlist
                 Default value is 0.7.
             */
             /*!
                 \qmlproperty real PieSeries::size
                 Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (pie not drawn).
                 \o 1.0 is the maximum size that can fit the chart.
                 \endlist
                 Default value is 0.7.
             */
             /*!
                 \property QPieSeries::donutInnerSize
                 \brief Defines the donut inner size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (pie not drawn).
                 \o 1.0 is the maximum size that can fit the chart. (donut has no width)
                 \endlist
                 The value is never greater then size property.
                 Default value is 0.5.
             */
             /*!
                 \qmlproperty real PieSeries::donutInnerSize
                 Defines the donut inner size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (donut is a pie).
                 \o 1.0 is the maximum size that can fit the chart. (donut has no width)
                 \endlist
                 The value is never greater then size property.
                 Default value is 0.5.
             */
             /*!
                 \property QPieSeries::startAngle
                 \brief Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \qmlproperty real PieSeries::startAngle
                 Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \property QPieSeries::endAngle
                 \brief Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 \qmlproperty real PieSeries::endAngle
                 Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 \property QPieSeries::count
                 Number of slices in the series.
             */
             /*!
                 \qmlproperty int PieSeries::count
                 Number of slices in the series.
             */
             /*!
                 \property QPieSeries::donut
                 Defines whether the series should be drawn as a donut
             */
             /*!
                 \qmlproperty int PieSeries::donut
                 Defines whether the series should be drawn as a donut
             */
             /*!
                 \fn void QPieSeries::countChanged()
                 Emitted when the slice count has changed.
                 \sa count
             */
             /*!
                 \qmlsignal PieSeries::onCountChanged()
                 Emitted when the slice count has changed.
             */
             /*!
                 \property QPieSeries::sum
                 Sum of all slices.
                 The series keeps track of the sum of all slices it holds.
             */
             /*!
                 \qmlproperty real PieSeries::sum
                 Sum of all slices.
                 The series keeps track of the sum of all slices it holds.
             */
             /*!
                 \fn void QPieSeries::sumChanged()
                 Emitted when the sum of all slices has changed.
                 \sa sum
             */
             /*!
                 \qmlsignal PieSeries::onSumChanged()
                 Emitted when the sum of all slices has changed. This may happen for example if you add or remove slices, or if you
                 change value of a slice.
             */
             /*!
                 \fn void QPieSeries::added(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal PieSeries::onAdded(PieSlice slice)
                 Emitted when \a slice has been added to the series.
             */
             /*!
                 \fn void QPieSeries::removed(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been removed from the series.
                 \sa remove()
             */
             /*!
                 \qmlsignal PieSeries::onRemoved(PieSlice slice)
                 Emitted when \a slice has been removed from the series.
             */
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
               \qmlsignal PieSeries::onClicked(PieSlice slice)
               This signal is emitted when a \a slice has been clicked.
             */
             /*!
                 \fn void QPieSeries::hovered(QPieSlice* slice, bool state)
                 This signal is emitted when user has hovered over or away from the \a slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
                 \sa QPieSlice::hovered()
             */
             /*!
                 \qmlsignal PieSeries::onHovered(PieSlice slice, bool state)
                 This signal is emitted when user has hovered over or away from the \a slice. \a state is true when user has hovered
                 over the slice and false when hover has moved away from the slice.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::at(int index)
                 Returns slice at \a index. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::find(string label)
                 Returns the first slice with \a label. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::append(string label, real value)
                 Adds a new slice with \a label and \a value to the pie.
             */
             /*!
                 \qmlmethod bool PieSeries::remove(PieSlice slice)
                 Removes the \a slice from the pie. Returns true if the removal was successfull, false otherwise.
             */
             /*!
                 \qmlmethod PieSeries::clear()
                 Removes all slices from the pie.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
                 QAbstractSeries(*new QPieSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destroys the series and its slices.
             */
             QPieSeries::~QPieSeries()
             {
                 // NOTE: d_prt destroyed by QObject
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QAbstractSeries::SeriesType QPieSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePie;
             }
             /*!
                 Appends a single \a slice to the series.
                 Slice ownership is passed to the series.
                 Returns true if append was succesfull.
             */
             bool QPieSeries::append(QPieSlice* slice)
             {
                 return append(QList<QPieSlice*>() << slice);
             }
             /*!
                 Appends an array of \a slices to the series.
                 Slice ownership is passed to the series.
                 Returns true if append was successfull.
             */
             bool QPieSeries::append(QList<QPieSlice*> slices)
             {
                 Q_D(QPieSeries);
                 if (slices.count() == 0)
                     return false;
                 foreach (QPieSlice* s, slices) {
                     if (!s || d->m_slices.contains(s))
                         return false;
                     if (s->series()) // already added to some series
                         return false;
                 }
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     QPieSlicePrivate::fromSlice(s)->m_series = this;
                     d->m_slices << s;
                 }
                 d->updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                     connect(s, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 }
                 emit added(slices);
                 emit countChanged();
                 return true;
             }
             /*!
                 Appends a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries& QPieSeries::operator << (QPieSlice* slice)
             {
                 append(slice);
                 return *this;
             }
             /*!
                 Appends a single slice to the series with give \a value and \a label.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::append(QString label, qreal value)
             {
                 QPieSlice* slice = new QPieSlice(label, value);
                 append(slice);
                 return slice;
             }
             /*!
                 Inserts a single \a slice to the series before the slice at \a index position.
                 Slice ownership is passed to the series.
                 Returns true if insert was successfull.
             */
             bool QPieSeries::insert(int index, QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (index < 0 || index > d->m_slices.count())
                     return false;
                 if (!slice || d->m_slices.contains(slice))
                     return false;
                 if (slice->series()) // already added to some series
                     return false;
                 slice->setParent(this);
                 QPieSlicePrivate::fromSlice(slice)->m_series = this;
                 d->m_slices.insert(index, slice);
                 d->updateDerivativeData();
                 connect(slice, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                 connect(slice, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                 connect(slice, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 emit added(QList<QPieSlice*>() << slice);
                 emit countChanged();
                 return true;
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference the pointer after this call.
                 Returns true if remove was successfull.
             */
             bool QPieSeries::remove(QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice))
                     return false;
                 d->updateDerivativeData();
                 emit removed(QList<QPieSlice*>() << slice);
                 emit countChanged();
                 delete slice;
                 slice = 0;
                 return true;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 Q_D(QPieSeries);
                 if (d->m_slices.count() == 0)
                     return;
                 QList<QPieSlice*> slices = d->m_slices;
                 foreach (QPieSlice* s, d->m_slices) {
                     d->m_slices.removeOne(s);
                     delete s;
                 }
                 d->updateDerivativeData();
                 emit removed(slices);
                 emit countChanged();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices;
             }
             /*!
                 returns the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.count();
             }
             /*!
                 Returns true is the series is empty.
             */
             bool QPieSeries::isEmpty() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.isEmpty();
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue(), QPieSlice::percentage()
             */
             qreal QPieSeries::sum() const
             {
                 Q_D(const QPieSeries);
                 return d->m_sum;
             }
             void QPieSeries::setDonut(bool donut)
             {
                 Q_D(QPieSeries);
                 d->m_donutChart = donut;
                 d->updateDerivativeData();
             }
             bool QPieSeries::donut() const
             {
                 Q_D(const QPieSeries);
                 return d->m_donutChart;
             }
             void QPieSeries::setDonutInnerSize(qreal innerSize)
             {
                 Q_D(QPieSeries);
                 if (innerSize < 0.0)
                     innerSize = 0.0;
                 if (innerSize > d->m_pieRelativeSize)
                     innerSize = d->m_pieRelativeSize;
                 d->m_donutRelativeInnerSize = innerSize;
                 d->updateDerivativeData();
                 emit d->pieSizeChanged();
             }
             qreal QPieSeries::donutInnerSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_donutRelativeInnerSize;
             }
             void QPieSeries::setHorizontalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (relativePosition < 0.0)
                     relativePosition = 0.0;
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
                 if (!qFuzzyIsNull(d->m_pieRelativeHorPos - relativePosition)) {
                     d->m_pieRelativeHorPos = relativePosition;
                     emit d->horizontalPositionChanged();
                 }
             }
             qreal QPieSeries::horizontalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeHorPos;
             }
             void QPieSeries::setVerticalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (relativePosition < 0.0)
                     relativePosition = 0.0;
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
                 if (!qFuzzyIsNull(d->m_pieRelativeVerPos - relativePosition)) {
                     d->m_pieRelativeVerPos = relativePosition;
                     emit d->verticalPositionChanged();
                 }
             }
             qreal QPieSeries::verticalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeVerPos;
             }
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 Q_D(QPieSeries);
                 if (relativeSize < 0.0)
                     relativeSize = 0.0;
                 if (relativeSize > 1.0)
                     relativeSize = 1.0;
                 if (!qFuzzyIsNull(d->m_pieRelativeSize - relativeSize)) {
                     d->m_pieRelativeSize = relativeSize;
                     emit d->pieSizeChanged();
                 }
             }
             qreal QPieSeries::pieSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeSize;
             }
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (qFuzzyIsNull(d->m_pieStartAngle - angle))
                     return;
                 d->m_pieStartAngle = angle;
                 d->updateDerivativeData();
                 emit d->pieStartAngleChanged();
             }
             qreal QPieSeries::pieStartAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieStartAngle;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be greater than start angle.
                 \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (qFuzzyIsNull(d->m_pieEndAngle - angle))
                     return;
                 d->m_pieEndAngle = angle;
                 d->updateDerivativeData();
                 emit d->pieEndAngleChanged();
             }
             /*!
                 Returns the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             qreal QPieSeries::pieEndAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 Note that this affects only the current slices in the series.
                 If user adds a new slice the default label visibility is false.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, d->m_slices)
                     s->setLabelVisible(visible);
             }
             void QPieSeries::setLabelsPosition(QPieSlice::LabelPosition position)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, d->m_slices)
                     s->setLabelPosition(position);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent) :
                 QAbstractSeriesPrivate(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_sum(0),
                 m_donutChart(false),
                 m_donutRelativeInnerSize(0.5)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
             }
             void QPieSeriesPrivate::updateDerivativeData()
             {
                 // calculate sum of all slices
                 qreal sum = 0;
                 foreach (QPieSlice* s, m_slices)
                     sum += s->value();
                 if (!qFuzzyIsNull(m_sum - sum)) {
                     m_sum = sum;
                     emit q_func()->sumChanged();
                 }
                 // nothing to show..
                 if (qFuzzyIsNull(m_sum))
                     return;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice*> changed;
                 foreach (QPieSlice* s, m_slices) {
                     QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
                     d->setPercentage(s->value() / m_sum);
                     d->setStartAngle(sliceAngle);
                     d->setAngleSpan(pieSpan * s->percentage());
                     sliceAngle += s->angleSpan();
                 }
                 emit calculatedDataChanged();
             }
             QPieSeriesPrivate* QPieSeriesPrivate::fromSeries(QPieSeries *series)
             {
                 return series->d_func();
             }
             void QPieSeriesPrivate::sliceValueChanged()
             {
                 Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
                 updateDerivativeData();
             }
             void QPieSeriesPrivate::sliceClicked()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->clicked(slice);
             }
             void QPieSeriesPrivate::sliceHovered(bool state)
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hovered(slice, state);
             }
             void QPieSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_UNUSED(domain);
                 // does not apply to pie
             }
             Chart* QPieSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QPieSeries);
                 PieChartItem* pie = new PieChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
-                    presenter->animator()->addAnimation(pie);
+                    pie->setAnimation(new PieAnimation(pie));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return pie;
             }
             QList<LegendMarker*> QPieSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QPieSeries);
                 QList<LegendMarker*> markers;
                 foreach(QPieSlice* slice, q->slices()) {
                     PieLegendMarker* marker = new PieLegendMarker(q,slice,legend);
                     markers << marker;
                 }
                 return markers;
             }
             void QPieSeriesPrivate::initializeAxis(QAbstractAxis* axis)
             {
                 Q_UNUSED(axis);
             }
             QAbstractAxis::AxisType QPieSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeNoAxis;
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterchart/qscatterseries.cpp 0 -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$
             **
             ****************************************************************************/
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "scatterchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
-            #include "chartanimator_p.h"
             /*!
                 \class QScatterSeries
                 \brief The QScatterSeries class is used for making scatter charts.
                 \mainclass
                 The scatter data is displayed as a collection of points on the chart. Each point determines the position on the horizontal axis
                 and the vertical axis.
                 \image examples_scatterchart.png
                 Creating basic scatter chart is simple:
                 \code
                 QScatterSeries* series = new QScatterSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chart->addSeries(series);
                 \endcode
             */
             /*!
                 \qmlclass ScatterSeries QScatterSeries
                 \inherits XYSeries
                 The following QML shows how to create a chart with two simple scatter series:
                 \snippet ../demos/qmlchart/qml/qmlchart/View5.qml 1
                 \snippet ../demos/qmlchart/qml/qmlchart/View5.qml 2
                 \beginfloatleft
                 \image demos_qmlchart5.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \enum QScatterSeries::MarkerShape
                 This enum describes the shape used when rendering marker items.
                 \value MarkerShapeCircle
                 \value MarkerShapeRectangle
             */
             /*!
                 \property QScatterSeries::color
                 Fill (brush) color of the series. This is a convenience property for modifying the color of brush.
                 \sa QScatterSeries::brush()
             */
             /*!
                 \property QScatterSeries::borderColor
                 Line (pen) color of the series. This is a convenience property for modifying the color of pen.
                 \sa QScatterSeries::pen()
             */
             /*!
                 \property QScatterSeries::markerShape
                 Defines the shape of the marker used to draw the points in the series. The default shape is MarkerShapeCircle.
             */
             /*!
                 \qmlproperty MarkerShape ScatterSeries::markerShape
                 Defines the shape of the marker used to draw the points in the series. One of ScatterSeries
                 ScatterSeries.MarkerShapeCircle or ScatterSeries.MarkerShapeRectangle.
                 The default shape is ScatterSeries.MarkerShapeCircle.
             */
             /*!
                 \property QScatterSeries::markerSize
                 Defines the size of the marker used to draw the points in the series. The default size is 15.0.
             */
             /*!
                 \qmlproperty real ScatterSeries::markerSize
                 Defines the size of the marker used to draw the points in the series. The default size is 15.0.
             */
             /*!
                 \fn void QScatterSeries::colorChanged(QColor color)
                 Signal is emitted when the fill (brush) color has changed to \a color.
             */
             /*!
                 \fn void QScatterSeries::borderColorChanged(QColor color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \qmlsignal ScatterSeries::borderColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn QChartSeriesType QScatterSeries::type() const
                 Returns QChartSeries::SeriesTypeScatter.
                 \sa QAbstractSeries, SeriesType
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QScatterSeries::QScatterSeries(QObject *parent) : QXYSeries(*new QScatterSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QScatterSeries::~QScatterSeries()
             {
                 Q_D(QScatterSeries);
                 if(d->m_dataset) {
                     d->m_dataset->removeSeries(this);
                 }
             }
             QAbstractSeries::SeriesType QScatterSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeScatter;
             }
             /*!
                 Sets \a pen used for drawing points' border on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QScatterSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen != pen) {
                     bool emitColorChanged = d->m_pen.color() != pen.color();
                     d->m_pen = pen;
                     emit d->updated();
                     if (emitColorChanged)
                         emit borderColorChanged(pen.color());
                 }
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setTheme()
             */
             void QScatterSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QScatterSeries);
                 if (d->m_brush != brush) {
                     bool emitColorChanged = d->m_brush.color() != brush.color();
                     d->m_brush = brush;
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(brush.color());
                 }
             }
             void QScatterSeries::setColor(const QColor &color)
             {
                 QBrush b = brush();
                 if (b.color() != color) {
                     b.setColor(color);
                     setBrush(b);
                 }
             }
             QColor QScatterSeries::color() const
             {
                 return brush().color();
             }
             void QScatterSeries::setBorderColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QScatterSeries::borderColor() const
             {
                 return pen().color();
             }
             QScatterSeries::MarkerShape QScatterSeries::markerShape() const
             {
                 Q_D(const QScatterSeries);
                 return d->m_shape;
             }
             void QScatterSeries::setMarkerShape(MarkerShape shape)
             {
                 Q_D(QScatterSeries);
                 if (d->m_shape != shape) {
                     d->m_shape = shape;
                     emit d->updated();
                 }
             }
             qreal QScatterSeries::markerSize() const
             {
                 Q_D(const QScatterSeries);
                 return d->m_size;
             }
             void QScatterSeries::setMarkerSize(qreal size)
             {
                 Q_D(QScatterSeries);
                 if (!qFuzzyIsNull(d->m_size - size)) {
                     d->m_size = size;
                     emit d->updated();
                 }
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QScatterSeriesPrivate::QScatterSeriesPrivate(QScatterSeries* q) :
                 QXYSeriesPrivate(q),
                 m_shape(QScatterSeries::MarkerShapeCircle),
                 m_size(15.0)
             {
             }
             Chart* QScatterSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QScatterSeries);
                 ScatterChartItem *scatter = new ScatterChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
-                    scatter->setAnimator(presenter->animator());
                     scatter->setAnimation(new XYAnimation(scatter));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return scatter;
             }
             #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.cpp +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$
             **
             ****************************************************************************/
             #include "qsplineseries.h"
             #include "qsplineseries_p.h"
             #include "splinechartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
-            #include "chartanimator_p.h"
+            #include "splineanimation_p.h"
             /*!
                 \class QSplineSeries
                 \brief Series type used to store data needed to draw a spline.
                 QSplineSeries stores the data points along with the segment control points needed by QPainterPath to draw spline
                 Control points are automatically calculated when data changes. The algorithm computes the points so that the normal spline can be drawn.
                 \image examples_splinechart.png
                 Creating basic spline chart is simple:
                 \code
                 QSplineSeries* series = new QSplineSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chart->addSeries(series);
                 \endcode
             */
             /*!
                 \qmlclass SplineSeries QSplineSeries
                 \inherits XYSeries
                 The following QML shows how to create a simple spline chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View3.qml 1
                 \beginfloatleft
                 \image demos_qmlchart3.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \fn QSeriesType QSplineSeries::type() const
                 Returns the type of the series
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance then the ownerships is transferred.
               */
             QSplineSeries::QSplineSeries(QObject *parent) :
                 QLineSeries(*new QSplineSeriesPrivate(this),parent)
             {
                 Q_D(QSplineSeries);
                 QObject::connect(this,SIGNAL(pointAdded(int)), d, SLOT(updateControlPoints()));
                 QObject::connect(this,SIGNAL(pointRemoved(int)), d, SLOT(updateControlPoints()));
                 QObject::connect(this,SIGNAL(pointReplaced(int)), d, SLOT(updateControlPoints()));
             }
             /*!
               Destroys the object.
             */
             QSplineSeries::~QSplineSeries()
             {
                 Q_D(QSplineSeries);
                 if(d->m_dataset){
                     d->m_dataset->removeSeries(this);
                 }
             }
             QAbstractSeries::SeriesType QSplineSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeSpline;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QSplineSeriesPrivate::QSplineSeriesPrivate(QSplineSeries* q):QLineSeriesPrivate(q)
             {
             }
             /*!
               Calculates control points which are needed by QPainterPath.cubicTo function to draw the cubic Bezier cureve between two points.
               */
             void QSplineSeriesPrivate::calculateControlPoints()
             {
                 Q_Q(QSplineSeries);
                 const QList<QPointF>& points = q->points();
                 int n = points.count() - 1;
                 if (n == 1)
                 {
                     //for n==1
                     m_controlPoints[0].setX((2 * points[0].x() + points[1].x()) / 3);
                     m_controlPoints[0].setY((2 * points[0].y() + points[1].y()) / 3);
                     m_controlPoints[1].setX(2 * m_controlPoints[0].x() - points[0].x());
                     m_controlPoints[1].setY(2 * m_controlPoints[0].y() - points[0].y());
                     return;
                 }
                 // Calculate first Bezier control points
                 // Set of equations for P0 to Pn points.
                 //
                 //  |   2   1   0   0   ... 0   0   0   ... 0   0   0   |   |   P1_1    |   |   P0 + 2 * P1             |
                 //  |   1   4   1   0   ... 0   0   0   ... 0   0   0   |   |   P1_2    |   |   4 * P1 + 2 * P2         |
                 //  |   0   1   4   1   ... 0   0   0   ... 0   0   0   |   |   P1_3    |   |   4 * P2 + 2 * P3         |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   ... 1   4   1   ... 0   0   0   | * |   P1_i    | = |   4 * P(i-1) + 2 * Pi     |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   0   0   0   0   ... 1   4   1   |   |   P1_(n-1)|   |   4 * P(n-2) + 2 * P(n-1) |
                 //  |   0   0   0   0   0   0   0   0   ... 0   2   7   |   |   P1_n    |   |   8 * P(n-1) + Pn         |
                 //
                 QVector<qreal> vector;
                 vector.resize(n);
                 vector[0] = points[0].x() + 2 * points[1].x();
                 for (int i = 1; i < n - 1; ++i){
                     vector[i] = 4 * points[i].x() + 2 * points[i + 1].x();
                 }
                 vector[n - 1] = (8 * points[n-1].x() + points[n].x()) / 2.0;
                 QVector<qreal> xControl = firstControlPoints(vector);
                 vector[0] = points[0].y() + 2 * points[1].y();
                 for (int i = 1; i < n - 1; ++i) {
                     vector[i] = 4 * points[i].y() + 2 * points[i + 1].y();
                 }
                 vector[n - 1] = (8 * points[n-1].y() + points[n].y()) / 2.0;
                 QVector<qreal> yControl = firstControlPoints(vector);
                 for (int i = 0,j =0; i < n; ++i, ++j) {
                     m_controlPoints[j].setX(xControl[i]);
                     m_controlPoints[j].setY(yControl[i]);
                     j++;
                     if (i < n - 1){
                         m_controlPoints[j].setX(2 * points[i+1].x() - xControl[i + 1]);
                         m_controlPoints[j].setY(2 * points[i+1].y() - yControl[i + 1]);
                     }else{
                         m_controlPoints[j].setX((points[n].x() + xControl[n - 1]) / 2);
                         m_controlPoints[j].setY((points[n].y() + yControl[n - 1]) / 2);
                     }
                 }
             }
             QVector<qreal> QSplineSeriesPrivate::firstControlPoints(const QVector<qreal>& vector)
             {
                 QVector<qreal> result;
                 int count = vector.count();
                 result.resize(count);
                 result[0] = vector[0] / 2.0;
                 QVector<qreal> temp;
                 temp.resize(count);
                 temp[0] = 0;
                 qreal b = 2.0;
                 for (int i = 1; i < count; i++) {
                     temp[i] = 1 / b;
                     b = (i < count - 1 ? 4.0 : 3.5) - temp[i];
                     result[i]=(vector[i] - result[i - 1]) / b;
                 }
                 for (int i = 1; i < count; i++)
                     result[count - i - 1] -= temp[count - i] * result[count - i];
                 return result;
             }
             QPointF QSplineSeriesPrivate::controlPoint(int index) const
             {
                 //    Q_D(const QSplineSeries);
                 //    return d->m_controlPoints[index];
                 return m_controlPoints[index];
             }
             /*!
               Updates the control points, besed on currently avaiable knots.
               */
             void QSplineSeriesPrivate::updateControlPoints()
             {
                 Q_Q(QSplineSeries);
                 if (q->count() > 1) {
                     m_controlPoints.resize(2*q->count()-2);
                     calculateControlPoints();
                 }
             }
             Chart* QSplineSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QSplineSeries);
                 SplineChartItem* spline  = new SplineChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
-                    spline->setAnimator(presenter->animator());
                     spline->setAnimation(new SplineAnimation(spline));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return spline;
             }
             #include "moc_qsplineseries.cpp"
             #include "moc_qsplineseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/splinechartitem.cpp +6 -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 "splinechartitem_p.h"
             #include "qsplineseries_p.h"
             #include "chartpresenter_p.h"
-            #include "chartanimator_p.h"
+            #include "splineanimation_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             SplineChartItem::SplineChartItem(QSplineSeries *series, ChartPresenter *presenter) :
                 XYChart(series, presenter),
                 QGraphicsItem(presenter ? presenter->rootItem() : 0),
                 m_series(series),
                 m_pointsVisible(false),
                 m_animation(0)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(m_series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF SplineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath SplineChartItem::shape() const
             {
                 return m_path;
             }
             void SplineChartItem::setAnimation(SplineAnimation* animation)
             {
                 m_animation=animation;
                 XYChart::setAnimation(animation);
             }
+            ChartAnimation* SplineChartItem::animation() const
+            {
+                return m_animation;
+            }
             void SplineChartItem::setControlGeometryPoints(QVector<QPointF>& points)
             {
                 m_controlPoints=points;
             }
             QVector<QPointF> SplineChartItem::controlGeometryPoints() const
             {
                 return m_controlPoints;
             }
             void SplineChartItem::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
             {
                 QVector<QPointF> controlPoints;
                 if(newPoints.count()>=2) {
                     controlPoints.resize(newPoints.count()*2-2);
                 }
                 for (int i = 0; i < newPoints.size() - 1; i++) {
                     controlPoints[2*i] = calculateGeometryControlPoint(2 * i);
                     controlPoints[2 * i + 1] = calculateGeometryControlPoint(2 * i + 1);
                 }
                 if (controlPoints.count()<2) {
                     setGeometryPoints(newPoints);
                     setControlGeometryPoints(controlPoints);
                     updateGeometry();
                     return;
                 }
                 if (m_animation) {
                     m_animation->setup(oldPoints,newPoints,m_controlPoints,controlPoints,index);
                     setGeometryPoints(newPoints);
                     setDirty(false);
                     presenter()->startAnimation(m_animation);
                 }
                 else {
                     setGeometryPoints(newPoints);
                     setControlGeometryPoints(controlPoints);
                     updateGeometry();
                 }
             }
             QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
             {
                 return XYChart::calculateGeometryPoint(m_series->d_func()->controlPoint(index));
             }
             void SplineChartItem::updateGeometry()
             {
                 const QVector<QPointF> &points = geometryPoints();
                 const QVector<QPointF> &controlPoints = controlGeometryPoints();
                 if ((points.size()<2) || (controlPoints.size()<2)) {
                 	prepareGeometryChange();
                     m_path = QPainterPath();
                     m_rect = QRect();
                     return;
                 }
                 Q_ASSERT(points.count()*2-2 == controlPoints.count());
                 QPainterPath splinePath(points.at(0));
                 for (int i = 0; i < points.size() - 1; i++) {
                     const QPointF& point = points.at(i + 1);
                     splinePath.cubicTo(controlPoints[2*i],controlPoints[2 * i + 1],point);
                 }
                 prepareGeometryChange();
                 m_path = splinePath;
                 m_rect = splinePath.boundingRect();
                 setPos(origin());
             }
             //handlers
             void SplineChartItem::handleUpdated()
             {
                 setVisible(m_series->isVisible());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2*m_pointPen.width());
                 update();
             }
             //painter
             void SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setClipRect(clipRect());
                 painter->setPen(m_linePen);
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                     painter->setPen(m_pointPen);
                     painter->drawPoints(geometryPoints());
                 }
                 painter->restore();
             }
             void SplineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::clicked(calculateDomainPoint(event->pos()));
             }
             #include "moc_splinechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/splinechartitem_p.h +3 -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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef SPLINECHARTITEM_P_H
             #define SPLINECHARTITEM_P_H
             #include "qsplineseries.h"
             #include "xychart_p.h"
-            #include "splineanimation_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            class SplineAnimation;
             class SplineChartItem : public XYChart, public QGraphicsItem
             {
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsItem)
             public:
                 SplineChartItem(QSplineSeries *series, ChartPresenter *presenter);
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
                 void setControlGeometryPoints(QVector<QPointF>& points);
                 QVector<QPointF> controlGeometryPoints() const;
                 void setAnimation(SplineAnimation* animation);
-                ChartAnimation* animation() const { return m_animation; }
+                ChartAnimation* animation() const;
             public Q_SLOTS:
                 void handleUpdated();
             protected:
                 void updateGeometry();
                 void updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index);
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             private:
                 QPointF calculateGeometryControlPoint(int index) const;
             private:
                 QSplineSeries *m_series;
                 QPainterPath m_path;
                 QRectF m_rect;
                 QPen m_linePen;
                 QPen m_pointPen;
                 bool m_pointsVisible;
                 QVector<QPointF> m_controlPoints;
                 SplineAnimation* m_animation;
                 friend class SplineAnimation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SPLINECHARTITEM_P_H

src/xychart/xychart.cpp +2 -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 "xychart_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "chartpresenter_p.h"
-            #include "chartanimator_p.h"
             #include "domain_p.h"
+            #include "qxymodelmapper.h"
             #include <QPainter>
             #include <QAbstractItemModel>
-            #include "qxymodelmapper.h"
-            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             XYChart::XYChart(QXYSeries *series, ChartPresenter *presenter):Chart(presenter),
             m_minX(0),
             m_maxX(0),
             m_minY(0),
             m_maxY(0),
             m_series(series),
             m_animation(0),
             m_dirty(true)
             {
             //    QObject::connect(series->d_func(),SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
             //    QObject::connect(series->d_func(),SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
             //    QObject::connect(series->d_func(),SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
                 QObject::connect(series, SIGNAL(pointReplaced(int)), this,SLOT(handlePointReplaced(int)));
                 QObject::connect(series, SIGNAL(pointAdded(int)), this,SLOT(handlePointAdded(int)));
                 QObject::connect(series, SIGNAL(pointRemoved(int)), this,SLOT(handlePointRemoved(int)));
                 QObject::connect(this, SIGNAL(clicked(QPointF)), series,SIGNAL(clicked(QPointF)));
             }
             void XYChart::setGeometryPoints(const QVector<QPointF>& points)
             {
                 m_points = points;
             }
             void XYChart::setClipRect(const QRectF &rect)
             {
                 m_clipRect = rect;
             }
             void XYChart::setAnimation(XYAnimation* animation)
             {
                 m_animation=animation;
             }
             void XYChart::setDirty(bool dirty)
             {
             	m_dirty=dirty;
             }
             QPointF XYChart::calculateGeometryPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = (point.x() - m_minX)* deltaX;
                 qreal y = (point.y() - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QPointF XYChart::calculateGeometryPoint(int index) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 const QList<QPointF>& vector = m_series->points();
                 qreal x = (vector[index].x() - m_minX)* deltaX;
                 qreal y = (vector[index].y() - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QVector<QPointF> XYChart::calculateGeometryPoints() const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 QVector<QPointF> result;
                 result.resize(m_series->count());
                 const QList<QPointF>& vector = m_series->points();
                 for (int i = 0; i < m_series->count(); ++i) {
                     qreal x = (vector[i].x() - m_minX)* deltaX;
                     qreal y = (vector[i].y() - m_minY)*-deltaY + m_size.height();
                     result[i].setX(x);
                     result[i].setY(y);
                 }
                 return result;
             }
             QPointF XYChart::calculateDomainPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = point.x()/deltaX +m_minX;
                 qreal y = (point.y()-m_size.height())/(-deltaY)+ m_minY;
                 return QPointF(x,y);
             }
             void XYChart::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
             {
                 if (m_animation) {
                     m_animation->setup(oldPoints, newPoints, index);
                     setGeometryPoints(newPoints);
                     setDirty(false);
                     presenter()->startAnimation(m_animation);
                 }
                 else {
                     setGeometryPoints(newPoints);
                     updateGeometry();
                 }
             }
             //handlers
             void XYChart::handlePointAdded(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QVector<QPointF> points;
             	if(m_dirty) {
             		points = calculateGeometryPoints();
             	} else {
             		points = m_points;
             		QPointF point = calculateGeometryPoint(index);
             		points.insert(index, point);
             	}
                 updateChart(m_points,points,index);
             }
             void XYChart::handlePointRemoved(int index)
             {
             	Q_ASSERT(index<=m_series->count());
             	Q_ASSERT(index>=0);
             	QVector<QPointF> points;
             	if(m_dirty) {
             		points = calculateGeometryPoints();
             	} else {
             		points = m_points;
             		points.remove(index);
             	}
             	updateChart(m_points,points,index);
             }
             void XYChart::handlePointReplaced(int index)
             {
             	Q_ASSERT(index<m_series->count());
             	Q_ASSERT(index>=0);
             	QVector<QPointF> points;
             	if(m_dirty) {
             		points = calculateGeometryPoints();
             	} else {
             		QPointF point = calculateGeometryPoint(index);
             		points = m_points;
             		points.replace(index,point);
             	}
             	updateChart(m_points,points,index);
             }
             void XYChart::handleDomainUpdated()
             {
                 m_minX=domain()->minX();
                 m_maxX=domain()->maxX();
                 m_minY=domain()->minY();
                 m_maxY=domain()->maxY();
                 if (isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 updateChart(m_points,points);
             }
             void XYChart::handleGeometryChanged(const QRectF &rect)
             {
                 Q_ASSERT(rect.isValid());
                 m_size=rect.size();
                 m_clipRect=rect.translated(-rect.topLeft());
                 m_origin=rect.topLeft();
                 if (isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 updateChart(m_points,points);
             }
             bool XYChart::isEmpty()
             {
                 return !m_clipRect.isValid() || qFuzzyIsNull(m_maxX - m_minX) || qFuzzyIsNull(m_maxY - m_minY) || m_series->points().isEmpty();
             }
             #include "moc_xychart_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/chartanimator.cpp removed 0 -93

NO CONTENT: file was removed

src/animations/chartanimator_p.h removed 0 -70

NO CONTENT: file was removed

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