From d482058261e42b98b235e39c66b2e41035d8c76c 2012-03-09 15:14:06
From: Michal Klocek <michal.klocek@digia.com>
Date: 2012-03-09 15:14:06
Subject: [PATCH] Animation refactor
 * removes animation per derived item desing
 * new design aims to make centralized animation hadnling
 * removes animationitem and animator templets
 * removes axisanimationitem
 * adds chartanimator
 * adds chartanimatioms
 * add axis and xy animations

---

diff --git a/examples/zoomlinechart/main.cpp b/examples/zoomlinechart/main.cpp
index 0e307f8..cfedc80 100644
--- a/examples/zoomlinechart/main.cpp
+++ b/examples/zoomlinechart/main.cpp
@@ -33,6 +33,7 @@ int main(int argc, char *argv[])
     ChartWidget* chartWidget =  new ChartWidget(&window);
     chartWidget->setRenderHint(QPainter::Antialiasing);
     chartWidget->setChartTitle("Zoom in/out line chart example");
+    chartWidget->setAnimationOptions(QChart::AllAnimations);
     chartWidget->addSeries(series0);
     chartWidget->addSeries(series1);
 
diff --git a/src/animations/animations.pri b/src/animations/animations.pri
new file mode 100644
index 0000000..124acee
--- /dev/null
+++ b/src/animations/animations.pri
@@ -0,0 +1,13 @@
+INCLUDEPATH += $$PWD
+DEPENDPATH += $$PWD
+
+SOURCES += \
+    $$PWD/axisanimation.cpp \
+    $$PWD/chartanimator.cpp \
+    $$PWD/xyanimation.cpp
+
+PRIVATE_HEADERS += \
+    $$PWD/axisanimation_p.h \
+    $$PWD/chartanimator_p.h \
+    $$PWD/chartanimation_p.h \
+    $$PWD/xyanimation_p.h
\ No newline at end of file
diff --git a/src/animations/axisanimation.cpp b/src/animations/axisanimation.cpp
new file mode 100644
index 0000000..fe07afd
--- /dev/null
+++ b/src/animations/axisanimation.cpp
@@ -0,0 +1,45 @@
+#include "axisanimation_p.h"
+#include <QTimer>
+
+Q_DECLARE_METATYPE(QVector<qreal>)
+
+QTCOMMERCIALCHART_BEGIN_NAMESPACE
+
+
+AxisAnimation::AxisAnimation(AxisItem *axis): ChartAnimation(axis),
+    m_axis(axis)
+{
+}
+
+AxisAnimation::~AxisAnimation()
+{
+}
+
+QVariant AxisAnimation::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const
+{
+    QVector<qreal> startVector = qVariantValue<QVector<qreal> >(start);
+    QVector<qreal> endVecotr = qVariantValue<QVector<qreal> >(end);
+    QVector<qreal> result;
+
+    Q_ASSERT(startVector.count() == endVecotr.count()) ;
+
+    for(int i =0 ;i< startVector.count();i++){
+           qreal value = startVector[i] + ((endVecotr[i]- startVector[i]) * progress);//qBound(0.0, progress, 1.0));
+           result << value;
+    }
+    return qVariantFromValue(result);
+}
+
+
+void AxisAnimation::updateCurrentValue (const QVariant & value )
+{
+    if(state()!=QAbstractAnimation::Stopped)//workaround
+    {
+        QVector<qreal> vector = qVariantValue<QVector<qreal> >(value);
+        Q_ASSERT(vector.count()!=0);
+        m_axis->setLayout(vector);
+    }
+
+}
+
+QTCOMMERCIALCHART_END_NAMESPACE
diff --git a/src/axis/axisanimationitem_p.h b/src/animations/axisanimation_p.h
similarity index 55%
rename from src/axis/axisanimationitem_p.h
rename to src/animations/axisanimation_p.h
index 06ac92e..3b28bab 100644
--- a/src/axis/axisanimationitem_p.h
+++ b/src/animations/axisanimation_p.h
@@ -1,37 +1,17 @@
 #ifndef AXISANIMATIONITEM_H_
 #define AXISANIMATIONITEM_H_
 
-#include "domain_p.h"
 #include "axisitem_p.h"
-#include <QGraphicsItem>
-#include <QVariantAnimation>
+#include "chartanimation_p.h"
 
-QTCOMMERCIALCHART_BEGIN_NAMESPACE
-
-class AxisAnimator;
-
-class AxisAnimationItem : public AxisItem
-{
-    Q_OBJECT
-
-public:
-    AxisAnimationItem(QChartAxis* axis,AxisType type = X_AXIS,QGraphicsItem* parent = 0);
-    ~AxisAnimationItem();
 
-    void setLabelsAngle(int angle);
-
-protected:
-    virtual void updateLayout(QVector<qreal>& layout);
-
-private:
-    AxisAnimator *m_animation;
-};
+QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
-class AxisAnimator: public QVariantAnimation
+class AxisAnimation: public ChartAnimation
 {
 public:
-    AxisAnimator(AxisItem *axis,QObject *parent = 0);
-    ~AxisAnimator();
+    AxisAnimation(AxisItem *axis);
+    ~AxisAnimation();
 protected:
     virtual QVariant interpolated (const QVariant & from, const QVariant & to, qreal progress ) const;
     virtual void updateCurrentValue (const QVariant & value );
diff --git a/src/animations/chartanimation_p.h b/src/animations/chartanimation_p.h
new file mode 100644
index 0000000..dd46b6a
--- /dev/null
+++ b/src/animations/chartanimation_p.h
@@ -0,0 +1,19 @@
+#ifndef CHARTANIMATION_H_
+#define CHARTANIMATION_H_
+
+#include "qchartglobal.h"
+#include <QVariantAnimation>
+
+QTCOMMERCIALCHART_BEGIN_NAMESPACE
+
+class ChartAnimation: public QVariantAnimation
+{
+public:
+    ChartAnimation(QObject* parent=0):QVariantAnimation(parent){};
+};
+
+QTCOMMERCIALCHART_END_NAMESPACE
+
+
+
+#endif /* AXISITEM_H_ */
diff --git a/src/animations/chartanimator.cpp b/src/animations/chartanimator.cpp
new file mode 100644
index 0000000..9ac19ee
--- /dev/null
+++ b/src/animations/chartanimator.cpp
@@ -0,0 +1,141 @@
+#include "chartanimator_p.h"
+#include "axisanimation_p.h"
+#include "xyanimation_p.h"
+#include "xychartitem_p.h"
+#include <QTimer>
+
+Q_DECLARE_METATYPE(QVector<QPointF>)
+Q_DECLARE_METATYPE(QVector<qreal>)
+
+QTCOMMERCIALCHART_BEGIN_NAMESPACE
+
+const static int duration = 1000;
+
+ChartAnimator::ChartAnimator(QObject *parent):QObject(parent)
+{
+}
+
+ChartAnimator::~ChartAnimator()
+{
+}
+
+void ChartAnimator::addAnimation(AxisItem* item)
+{
+    AxisAnimation* animation = static_cast<AxisAnimation*>(m_animations.value(item));
+
+    if(!animation) {
+        animation = new AxisAnimation(item);
+        m_animations.insert(item,animation);
+    }
+
+    item->setAnimator(this);
+}
+
+void ChartAnimator::addAnimation(XYChartItem*  item)
+{
+    XYAnimation* animation = static_cast<XYAnimation*>(m_animations.value(item));
+
+    if(!animation) {
+        animation = new XYAnimation(item);
+        m_animations.insert(item,animation);
+    }
+
+    item->setAnimator(this);
+}
+
+void ChartAnimator::removeAnimation(ChartItem* item)
+{
+    item->setAnimator(0);
+    m_animations.remove(item);
+}
+
+void ChartAnimator::applyLayout(AxisItem* item , QVector<qreal>& newLayout)
+{
+    AxisAnimation* animation = static_cast<AxisAnimation*>(m_animations.value(item));
+
+    if(!animation) return;
+
+    QVector<qreal> oldLayout = item->layout();
+
+    if(newLayout.count()==0) return;
+
+    if(item->zoomFactor()<0) {
+
+        QRectF rect = item->geometry();
+        oldLayout.resize(newLayout.count());
+
+        for(int i=0,j=oldLayout.count()-1;i<(oldLayout.count()+1)/2;i++,j--)
+        {
+            oldLayout[i]= item->axisType()==AxisItem::X_AXIS?rect.left():rect.bottom();
+            oldLayout[j]= item->axisType()==AxisItem::X_AXIS?rect.right():rect.top();
+        }
+
+    }
+    else {
+
+        int index = qMin(oldLayout.count()*item->zoomFactor(),newLayout.count()-1.0);
+        oldLayout.resize(newLayout.count());
+
+        for(int i=0;i<oldLayout.count();i++)
+        {
+            oldLayout[i]= oldLayout[index]; //axisType()==X_AXIS?rect.center.x():rect.center().y();
+        }
+    }
+
+    if(animation->state()!=QAbstractAnimation::Stopped) {
+        animation->stop();
+    }
+
+    animation->setDuration(duration);
+    animation->setEasingCurve(QEasingCurve::OutQuart);
+    QVariantAnimation::KeyValues value;
+    animation->setKeyValues(value); //workaround for wrong interpolation call
+    animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout));
+    animation->setKeyValueAt(1.0, qVariantFromValue(newLayout));
+
+    QTimer::singleShot(0,animation,SLOT(start()));
+}
+
+void ChartAnimator::applyLayout(XYChartItem* item, QVector<QPointF>& newPoints)
+{
+
+    XYAnimation* animation = static_cast<XYAnimation*>(m_animations.value(item));
+
+    if(!animation) return;
+
+    QVector<QPointF> oldPoints = item->points();
+
+    if(newPoints.count()==0) return;
+
+    bool empty = oldPoints.count()==0;
+    oldPoints.resize(newPoints.size());
+
+    if(animation->state()!=QAbstractAnimation::Stopped) {
+        animation->stop();
+    }
+
+    animation->setDuration(duration);
+    if(!empty)
+    animation->setAnimationType(XYAnimation::MoveDownAnimation);
+    else
+    animation->setAnimationType(XYAnimation::LineDrawAnimation);
+    animation->setEasingCurve(QEasingCurve::OutQuart);
+    animation->setValues(oldPoints,newPoints);
+    QTimer::singleShot(0,animation,SLOT(start()));
+}
+
+void ChartAnimator::updateLayout(XYChartItem* item, QVector<QPointF>& newPoints)
+{
+    XYAnimation* animation = static_cast<XYAnimation*>(m_animations.value(item));
+
+    if(!animation) return;
+
+    animation->setDuration(duration);
+    animation->setAnimationType(XYAnimation::MoveDownAnimation);
+    animation->setEasingCurve(QEasingCurve::OutQuart);
+    animation->updateValues(newPoints);
+
+    QTimer::singleShot(0,animation,SLOT(start()));
+}
+
+QTCOMMERCIALCHART_END_NAMESPACE
diff --git a/src/animations/chartanimator_p.h b/src/animations/chartanimator_p.h
new file mode 100644
index 0000000..fa145e6
--- /dev/null
+++ b/src/animations/chartanimator_p.h
@@ -0,0 +1,35 @@
+#ifndef CHARTANIMATOR_P_H_
+#define CHARTANIMATOR_P_H_
+#include "qchartglobal.h"
+#include "chartanimation_p.h"
+
+QTCOMMERCIALCHART_BEGIN_NAMESPACE
+
+class ChartItem;
+class XYChartItem;
+class AxisItem;
+
+
+class ChartAnimator : public QObject {
+
+public:
+    ChartAnimator(QObject *parent = 0);
+    virtual ~ChartAnimator();
+
+    void addAnimation(AxisItem* item);
+    void addAnimation(XYChartItem* item);
+
+    void removeAnimation(ChartItem* item);
+
+    void animationStarted();
+    void applyLayout(XYChartItem* item, QVector<QPointF>& layout);
+    void updateLayout(XYChartItem* item, QVector<QPointF>& layout);
+    void applyLayout(AxisItem* item, QVector<qreal>& layout);
+
+private:
+     QMap<ChartItem*,ChartAnimation*> m_animations;
+};
+
+QTCOMMERCIALCHART_END_NAMESPACE
+
+#endif
diff --git a/src/xychart/xychartanimator_p.h b/src/animations/xyanimation.cpp
similarity index 56%
rename from src/xychart/xychartanimator_p.h
rename to src/animations/xyanimation.cpp
index 313037c..a947ea2 100644
--- a/src/xychart/xychartanimator_p.h
+++ b/src/animations/xyanimation.cpp
@@ -1,103 +1,96 @@
-#ifndef XYCHARTANIMATOR_P_H_
-#define XYCHARTANIMATOR_P_H_
-#include "qchartglobal.h"
-#include <QVariantAnimation>
-#include <QPointF>
+#include "xyanimation_p.h"
+#include "xychartitem_p.h"
 
-QTCOMMERCIALCHART_BEGIN_NAMESPACE
-
-template <class T, class U>
-class XYChartAnimationItem;
+Q_DECLARE_METATYPE(QVector<QPointF>)
 
+QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
-template <class T, class U>
-class XYChartAnimator : public QVariantAnimation
-{
-public:
-	enum Animation { LineDrawAnimation, MoveDownAnimation, MoveUpAnimation };
-    XYChartAnimator(XYChartAnimationItem<T,U> *item, QObject *parent = 0 );
-    ~XYChartAnimator();
-    void setAnimationType(Animation type);
-
-protected:
-    QVariant interpolated(const QVariant &start, const QVariant & end, qreal progress ) const;
-    void updateCurrentValue (const QVariant & value );
-    void updateState ( QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
-
-private:
-    XYChartAnimationItem<T,U> *m_item;
-    Animation m_type;
-};
-
-template <class T, class U>
-XYChartAnimator<T,U>::XYChartAnimator(XYChartAnimationItem<T,U> *item , QObject *parent):QVariantAnimation(parent),
+XYAnimation::XYAnimation(XYChartItem *item):ChartAnimation(item),
     m_item(item),
-    m_type(MoveDownAnimation)
+    m_type(MoveDownAnimation),
+    m_dirty(false)
 {
 }
 
-template <class T,class U>
-XYChartAnimator<T,U>::~XYChartAnimator()
+XYAnimation::~XYAnimation()
 {
 }
 
-template <class T,class U>
-void XYChartAnimator<T,U>::setAnimationType(Animation type)
+void XYAnimation::setAnimationType(Animation type)
 {
     m_type=type;
 }
 
-template <class T, class U>
-QVariant XYChartAnimator<T,U>::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const
+void XYAnimation::setValues(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints)
 {
-	QVector<QPointF> startVector = qVariantValue<QVector<QPointF> >(start);
-	QVector<QPointF> endVector = qVariantValue<QVector<QPointF> >(end);
-	QVector<QPointF> result;
-
-	switch(m_type) {
-
-		case MoveDownAnimation: {
-
-			Q_ASSERT(startVector.count() == endVector.count());
-			for(int i =0;i< startVector.count();i++) {
-				qreal x = startVector[i].x() + ((endVector[i].x()- startVector[i].x()) * progress);
-				qreal y = startVector[i].y() + ((endVector[i].y()- startVector[i].y()) * progress);
-				result << QPointF(x,y);
-			}
-
-		}
-			break;
-		case LineDrawAnimation:{
-			for(int i =0;i< endVector.count()* qBound(0.0, progress, 1.0);i++) {
-				result << endVector[i];
-			}
-		}
-			break;
-		default:
-			qWarning()<<"Unknow type of animation";
-			break;
-	}
-
-	return qVariantFromValue(result);
+    setKeyValueAt(0.0, qVariantFromValue(oldPoints));
+    setKeyValueAt(1.0, qVariantFromValue(newPoints));
+    m_points = newPoints;
+    m_dirty=false;
 }
 
-template <class T, class U>
-void XYChartAnimator<T,U>::updateCurrentValue (const QVariant & value )
+void XYAnimation::updateValues(QVector<QPointF>& newPoints)
 {
-	if(state()!=QAbstractAnimation::Stopped){ //workaround
-	    QVector<QPointF> vector = qVariantValue<QVector<QPointF> >(value);
-	    m_item->setGeometry(vector);
-	}
+    if(state()!=QAbstractAnimation::Stopped) {
+        stop();
+        m_dirty=true;
+    }
+
+    if(m_dirty) {
+        m_points=newPoints;
+        m_dirty=false;
+    }
+
+    setKeyValueAt(0.0, qVariantFromValue(m_points));
+    setKeyValueAt(1.0, qVariantFromValue(newPoints));
 }
 
-template <class T, class U>
-void XYChartAnimator<T,U>::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
+QVariant XYAnimation::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const
 {
-	Q_UNUSED(oldState)
-	if (newState==QAbstractAnimation::Running) m_item->animationStarted();
-	QVariantAnimation::updateState(newState,oldState);
+    QVector<QPointF> startVector = qVariantValue<QVector<QPointF> >(start);
+    QVector<QPointF> endVector = qVariantValue<QVector<QPointF> >(end);
+    QVector<QPointF> result;
+
+    switch(m_type) {
+
+        case MoveDownAnimation: {
+
+            Q_ASSERT(startVector.count() == endVector.count());
+            for(int i =0;i< startVector.count();i++) {
+                qreal x = startVector[i].x() + ((endVector[i].x()- startVector[i].x()) * progress);
+                qreal y = startVector[i].y() + ((endVector[i].y()- startVector[i].y()) * progress);
+                result << QPointF(x,y);
+            }
+
+        }
+            break;
+        case LineDrawAnimation:{
+            for(int i =0;i< endVector.count()* qBound(0.0, progress, 1.0);i++) {
+                result << endVector[i];
+            }
+        }
+            break;
+        default:
+            qWarning()<<"Unknow type of animation";
+            break;
+    }
+
+    return qVariantFromValue(result);
 }
 
-QTCOMMERCIALCHART_END_NAMESPACE
+void XYAnimation::updateCurrentValue (const QVariant & value )
+{
+    if(state()!=QAbstractAnimation::Stopped){ //workaround
+        QVector<QPointF> vector = qVariantValue<QVector<QPointF> >(value);
+        m_item->setGeometry(vector);
+    }
+}
 
-#endif /* XYCHARTANIMATOR_P_H_ */
+void XYAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
+{
+    Q_UNUSED(oldState)
+    if (newState==QAbstractAnimation::Running)  m_dirty=true;
+    QVariantAnimation::updateState(newState,oldState);
+}
+
+QTCOMMERCIALCHART_END_NAMESPACE
diff --git a/src/animations/xyanimation_p.h b/src/animations/xyanimation_p.h
new file mode 100644
index 0000000..de6de8a
--- /dev/null
+++ b/src/animations/xyanimation_p.h
@@ -0,0 +1,34 @@
+#ifndef XYCHARTANIMATION_P_H_
+#define XYCHARTANIMATION_P_H_
+#include "chartanimation_p.h"
+#include <QPointF>
+
+QTCOMMERCIALCHART_BEGIN_NAMESPACE
+
+class XYChartItem;
+
+class XYAnimation : public ChartAnimation
+{
+public:
+	enum Animation { LineDrawAnimation, MoveDownAnimation, MoveUpAnimation };
+    XYAnimation(XYChartItem *item);
+    ~XYAnimation();
+    void setAnimationType(Animation type);
+    void setValues(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints);
+    void updateValues(QVector<QPointF>& newPoints);
+
+protected:
+    QVariant interpolated(const QVariant &start, const QVariant & end, qreal progress ) const;
+    void updateCurrentValue (const QVariant & value );
+    void updateState ( QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
+
+private:
+    XYChartItem *m_item;
+    Animation m_type;
+    QVector<QPointF> m_points;
+    bool m_dirty;
+};
+
+QTCOMMERCIALCHART_END_NAMESPACE
+
+#endif
diff --git a/src/areachart/areachartitem_p.h b/src/areachart/areachartitem_p.h
index d329de4..97c1783 100644
--- a/src/areachart/areachartitem_p.h
+++ b/src/areachart/areachartitem_p.h
@@ -7,7 +7,6 @@
 
 QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
-class ChartPresenter;
 class QAreaSeries;
 class AreaChartItem;
 
diff --git a/src/axis/axis.pri b/src/axis/axis.pri
index a1ea0a0..bfbdd88 100644
--- a/src/axis/axis.pri
+++ b/src/axis/axis.pri
@@ -2,13 +2,11 @@ INCLUDEPATH += $$PWD
 DEPENDPATH += $$PWD
 
 SOURCES += \
-    $$PWD/axisanimationitem.cpp \
     $$PWD/axisitem.cpp \
     $$PWD/qchartaxis.cpp \
     $$PWD/qchartaxiscategories.cpp 
     
 PRIVATE_HEADERS += \
-    $$PWD/axisanimationitem_p.h \
     $$PWD/axisitem_p.h 
 
 PUBLIC_HEADERS += \    
diff --git a/src/axis/axisanimationitem.cpp b/src/axis/axisanimationitem.cpp
deleted file mode 100644
index 8fbdc06..0000000
--- a/src/axis/axisanimationitem.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#include "axisanimationitem_p.h"
-#include <QTimer>
-
-Q_DECLARE_METATYPE(QVector<qreal>)
-
-QTCOMMERCIALCHART_BEGIN_NAMESPACE
-
-const static int duration = 500;
-
-AxisAnimationItem::AxisAnimationItem(QChartAxis* axis,AxisType type,QGraphicsItem* parent) :
-AxisItem(axis,type,parent),
-m_animation(new AxisAnimator(this,this))
-{
-}
-
-AxisAnimationItem::~AxisAnimationItem()
-{
-}
-
-void AxisAnimationItem::updateLayout(QVector<qreal>& newLayout)
-{
-
-    QVector<qreal> oldLayout = layout();
-
-    if(newLayout.count()==0) return;
-
-    if(zoomFactor()<0) {
-
-        QRectF rect = geometry();
-        oldLayout.resize(newLayout.count());
-
-        for(int i=0,j=oldLayout.count()-1;i<(oldLayout.count()+1)/2;i++,j--)
-        {
-            oldLayout[i]= axisType()==X_AXIS?rect.left():rect.bottom();
-            oldLayout[j]= axisType()==X_AXIS?rect.right():rect.top();
-        }
-
-    }
-    else {
-
-        int index = qMin(oldLayout.count()*zoomFactor(),newLayout.count()-1.0);
-        oldLayout.resize(newLayout.count());
-
-        for(int i=0;i<oldLayout.count();i++)
-        {
-            oldLayout[i]= oldLayout[index]; //axisType()==X_AXIS?rect.center.x():rect.center().y();
-        }
-    }
-
-    if(m_animation->state()!=QAbstractAnimation::Stopped) {
-        m_animation->stop();
-    }
-
-    m_animation->setDuration(duration);
-    m_animation->setEasingCurve(QEasingCurve::OutQuart);
-    QVariantAnimation::KeyValues value;
-    m_animation->setKeyValues(value); //workaround for wrong interpolation call
-    m_animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout));
-    m_animation->setKeyValueAt(1.0, qVariantFromValue(newLayout));
-
-    QTimer::singleShot(0,m_animation,SLOT(start()));
-}
-
-void AxisAnimationItem::setLabelsAngle(int angle)
-{
-    AxisItem::setLabelsAngle(angle);
-}
-
-AxisAnimator::AxisAnimator(AxisItem *axis,QObject *parent): QVariantAnimation(parent),
-    m_axis(axis)
-{
-}
-
-AxisAnimator::~AxisAnimator()
-{
-}
-
-QVariant AxisAnimator::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const
-{
-    QVector<qreal> startVector = qVariantValue<QVector<qreal> >(start);
-    QVector<qreal> endVecotr = qVariantValue<QVector<qreal> >(end);
-    QVector<qreal> result;
-
-    Q_ASSERT(startVector.count() == endVecotr.count());
-
-    for(int i =0 ;i< startVector.count();i++){
-           qreal value = startVector[i] + ((endVecotr[i]- startVector[i]) * progress);//qBound(0.0, progress, 1.0));
-           result << value;
-    }
-    return qVariantFromValue(result);
-}
-
-
-void AxisAnimator::updateCurrentValue (const QVariant & value )
-{
-    //Q_ASSERT(state()!=QAbstractAnimation::Stopped);
-    if(state()!=QAbstractAnimation::Stopped)//workaround
-    {
-        QVector<qreal> vector = qVariantValue<QVector<qreal> >(value);
-        m_axis->setLayout(vector);
-    }
-
-}
-
-#include "moc_axisanimationitem_p.cpp"
-
-QTCOMMERCIALCHART_END_NAMESPACE
diff --git a/src/axis/axisitem.cpp b/src/axis/axisitem.cpp
index 019cbf2..57cf070 100644
--- a/src/axis/axisitem.cpp
+++ b/src/axis/axisitem.cpp
@@ -1,6 +1,7 @@
 #include "axisitem_p.h"
 #include "qchartaxis.h"
 #include "chartpresenter_p.h"
+#include "chartanimator_p.h"
 #include <QPainter>
 #include <QDebug>
 
@@ -8,8 +9,9 @@ static int label_padding = 5;
 
 QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
-AxisItem::AxisItem(QChartAxis* axis,AxisType type,QGraphicsItem* parent) :
+AxisItem::AxisItem(QChartAxis* axis,ChartPresenter* presenter,AxisType type,QGraphicsItem* parent) :
 ChartItem(parent),
+m_presenter(presenter),
 m_chartAxis(axis),
 m_type(type),
 m_labelsAngle(0),
@@ -45,13 +47,14 @@ QRectF AxisItem::boundingRect() const
 
 void AxisItem::createItems(int count)
 {
+
     if(m_axis.children().size()==0)
            m_axis.addToGroup(new QGraphicsLineItem());
     for (int i = 0; i < count; ++i) {
            m_grid.addToGroup(new QGraphicsLineItem());
            m_labels.addToGroup(new QGraphicsSimpleTextItem());
-           if(m_grid.childItems().size()%2) m_shades.addToGroup(new QGraphicsRectItem());
            m_axis.addToGroup(new QGraphicsLineItem());
+          if((m_grid.childItems().size())%2 && m_grid.childItems().size()>2) m_shades.addToGroup(new QGraphicsRectItem());
        }
 }
 
@@ -63,16 +66,19 @@ void AxisItem::deleteItems(int count)
     QList<QGraphicsItem *> axis = m_axis.childItems();
 
     for (int i = 0; i < count; ++i) {
+        if(lines.size()%2 && lines.size()>1) delete(shades.takeLast());
         delete(lines.takeLast());
         delete(labels.takeLast());
-        if(lines.size()%2) delete(shades.takeLast());
         delete(axis.takeLast());
     }
 }
 
 void AxisItem::updateLayout(QVector<qreal>& layout)
 {
-    setLayout(layout);
+    if(m_animator){
+       m_animator->applyLayout(this,layout);
+    }
+    else setLayout(layout);
 }
 
 QStringList AxisItem::createLabels(int ticks, qreal min, qreal max) const
@@ -240,7 +246,7 @@ void AxisItem::setLayout(QVector<qreal>& layout)
 
 	if(diff!=0) handleAxisUpdated();
 
-    QStringList ticksList = createLabels(m_ticksCount,m_min,m_max);
+    QStringList ticksList = createLabels(layout.size(),m_min,m_max);
 
 	QList<QGraphicsItem *> lines = m_grid.childItems();
 	QList<QGraphicsItem *> labels = m_labels.childItems();
@@ -249,6 +255,7 @@ void AxisItem::setLayout(QVector<qreal>& layout)
 
 	Q_ASSERT(labels.size() == ticksList.size());
 	Q_ASSERT(layout.size() == ticksList.size());
+	Q_ASSERT(layout.size() == m_ticksCount);
 
 	switch (m_type)
 	{
@@ -265,7 +272,7 @@ void AxisItem::setLayout(QVector<qreal>& layout)
 				QPointF center = labelItem->boundingRect().center();
 				labelItem->setTransformOriginPoint(center.x(), center.y());
 				labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
-				if(i%2 && i+1 < layout.size()) {
+				if(i%2 && i+1 < layout.size() && i>1) {
 					QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2));
 					rectItem->setRect(layout[i],m_rect.top(),layout[i+1]-layout[i],m_rect.height());
 				}
@@ -288,7 +295,7 @@ void AxisItem::setLayout(QVector<qreal>& layout)
 				QPointF center = labelItem->boundingRect().center();
 				labelItem->setTransformOriginPoint(center.x(), center.y());
 				labelItem->setPos(m_rect.left() - labelItem->boundingRect().width() - label_padding , layout[i]-center.y());
-				if(i%2 && i+1 < layout.size()) {
+				if(i%2 && i+1 < layout.size() && i>1) {
 					QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2));
 					rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i]-layout[i+1]);
 				}
@@ -302,7 +309,6 @@ void AxisItem::setLayout(QVector<qreal>& layout)
 		break;
 	}
 
-	//if(diff!=0) handleAxisUpdated();
 	m_layoutVector=layout;
 }
 
@@ -391,6 +397,7 @@ void AxisItem::handleRangeChanged(qreal min, qreal max)
     m_min = min;
     m_max = max;
 
+
     m_ticksCount = qrand()%10;
 
     while(m_ticksCount<2){
@@ -408,7 +415,6 @@ void AxisItem::handleRangeChanged(qreal min, qreal max)
 
 void AxisItem::handleGeometryChanged(const QRectF& rect)
 {
-
     m_rect = rect;
     if(isEmpty()) return;
     QVector<qreal> layout = calculateLayout();
diff --git a/src/axis/axisitem_p.h b/src/axis/axisitem_p.h
index c847bd5..6ae1107 100644
--- a/src/axis/axisitem_p.h
+++ b/src/axis/axisitem_p.h
@@ -8,6 +8,7 @@
 QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
 class QChartAxis;
+class ChartPresenter;
 
 class AxisItem : public QObject, public ChartItem
 {
@@ -15,7 +16,7 @@ class AxisItem : public QObject, public ChartItem
 public:
     enum AxisType{X_AXIS,Y_AXIS};
 
-    AxisItem(QChartAxis* axis,AxisType type = X_AXIS,QGraphicsItem* parent = 0);
+    AxisItem(QChartAxis* axis,ChartPresenter* presenter,AxisType type = X_AXIS,QGraphicsItem* parent = 0);
     ~AxisItem();
 
     //from QGraphicsItem
@@ -50,6 +51,7 @@ public:
     void setLabelsFont(const QFont& font);
 
     inline QRectF geometry() const { return m_rect; }
+    inline QVector<qreal> layout() { return m_layoutVector;};
     inline qreal zoomFactor() const { return m_zoomFactor;}
 
 public slots:
@@ -59,19 +61,20 @@ public slots:
     void handleTicksCountChanged(int count);
     void handleGeometryChanged(const QRectF& size);
 
-public:
-    virtual void updateLayout(QVector<qreal>& layout);
-    void setLayout(QVector<qreal>& layout);
-    QVector<qreal> layout() { return m_layoutVector;};
 
 private:
     inline bool isEmpty();
     void createItems(int count);
     void deleteItems(int count);
+
     QVector<qreal> calculateLayout() const;
+    void updateLayout(QVector<qreal>& layout);
+    void setLayout(QVector<qreal>& layout);
+
     QStringList createLabels(int ticks, qreal min, qreal max) const;
 
 private:
+    ChartPresenter* m_presenter;
     QChartAxis* m_chartAxis;
     AxisType m_type;
     QRectF m_rect;
@@ -86,6 +89,8 @@ private:
     int m_ticksCount;
     qreal m_zoomFactor;
 
+    friend class AxisAnimation;
+
 };
 
 QTCOMMERCIALCHART_END_NAMESPACE
diff --git a/src/chartdataset.cpp b/src/chartdataset.cpp
index 83b4678..106d954 100644
--- a/src/chartdataset.cpp
+++ b/src/chartdataset.cpp
@@ -146,11 +146,9 @@ void ChartDataSet::calculateDomain(QSeries* series,Domain* domain) const
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, x);
                 maxY = qMax(maxY, y);
-                domain->setMinX(qMin(domain->minX(),x));
-                domain->setMinY(qMin(domain->minY(),y));
-                domain->setMaxX(qMax(domain->maxX(),x));
-                domain->setMaxY(qMax(domain->maxY(),y));
             }
+
+            domain->setRange(minX, maxX,  minY,  maxY);
             break;
         }
         case QSeries::SeriesTypeArea: {
diff --git a/src/chartitem_p.h b/src/chartitem_p.h
index 0d5dcaf..93b4cb3 100644
--- a/src/chartitem_p.h
+++ b/src/chartitem_p.h
@@ -6,17 +6,26 @@
 
 QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
-class ChartAnimationManager;
+class ChartAnimator;
 
 class ChartItem : public QGraphicsItem
 {
     enum ChartItemTypes{ AXIS_ITEM = UserType+1, XYLINE_ITEM};
 public:
-    ChartItem(QGraphicsItem* parent = 0):QGraphicsItem(parent){};
+    ChartItem(QGraphicsItem* parent = 0):QGraphicsItem(parent),
+    m_animator(0){};
     //TODO make pure
     virtual void handleGeometryChanged(const QRectF&){};
     virtual void handleDomainChanged(const Domain& domain){};
+
+    void setAnimator(ChartAnimator* animator){
+        m_animator=animator;
+    }
+
     virtual ~ChartItem(){};
+
+protected:
+    ChartAnimator* m_animator;
 };
 
 QTCOMMERCIALCHART_END_NAMESPACE
diff --git a/src/chartpresenter.cpp b/src/chartpresenter.cpp
index 1052294..af0e7de 100644
--- a/src/chartpresenter.cpp
+++ b/src/chartpresenter.cpp
@@ -3,6 +3,7 @@
 #include "chartpresenter_p.h"
 #include "chartdataset_p.h"
 #include "charttheme_p.h"
+#include "chartanimator_p.h"
 //series
 #include "qbarseries.h"
 #include "qstackedbarseries.h"
@@ -14,7 +15,6 @@
 #include "qsplineseries.h"
 //items
 #include "axisitem_p.h"
-#include "axisanimationitem_p.h"
 #include "areachartitem_p.h"
 #include "barpresenter_p.h"
 #include "stackedbarpresenter_p.h"
@@ -28,6 +28,7 @@ QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
 ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
     m_chart(chart),
+    m_animator(0),
     m_dataset(dataset),
     m_chartTheme(0),
     m_zoomIndex(0),
@@ -96,15 +97,12 @@ void ChartPresenter::setMargin(int margin)
 
 void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain)
 {
+    AxisItem* item = new AxisItem(axis,this,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
 
-    AxisItem* item ;
-
-    if(!m_options.testFlag(QChart::GridAxisAnimations))
-    {
-        item = new AxisItem(axis,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
-    }else{
-        item = new AxisAnimationItem(axis,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
+    if(m_options.testFlag(QChart::GridAxisAnimations)){
+        m_animator->addAnimation(item);
     }
+
     if(axis==m_dataset->axisX()){
         QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal)),item,SLOT(handleRangeChanged(qreal,qreal)));
         //initialize
@@ -114,7 +112,6 @@ void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain)
         QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal)),item,SLOT(handleRangeChanged(qreal,qreal)));
         //initialize
         item->handleRangeChanged(domain->minY(),domain->maxY());
-
     }
 
     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
@@ -122,12 +119,14 @@ void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain)
     item->handleGeometryChanged(m_rect);
     m_chartTheme->decorate(axis,item);
     m_axisItems.insert(axis,item);
+
 }
 
 void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
 {
     AxisItem* item = m_axisItems.take(axis);
     Q_ASSERT(item);
+    if(m_animator) m_animator->removeAnimation(item);
     delete item;
 }
 
@@ -139,11 +138,9 @@ void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
     case QSeries::SeriesTypeLine: {
 
         QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
-        LineChartItem* item;
+        LineChartItem* item = new LineChartItem(lineSeries,m_chart);
         if(m_options.testFlag(QChart::SeriesAnimations)){
-            item = new  LineChartAnimationItem(lineSeries,m_chart);
-        }else{
-            item = new LineChartItem(lineSeries,m_chart);
+            m_animator->addAnimation(item);
         }
         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
         QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
@@ -159,12 +156,9 @@ void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
     case QSeries::SeriesTypeArea: {
 
         QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
-        AreaChartItem* item;
+        AreaChartItem* item = new AreaChartItem(areaSeries,m_chart);
         if(m_options.testFlag(QChart::SeriesAnimations)) {
-            item = new AreaChartItem(areaSeries,m_chart);
-        }
-        else {
-            item = new AreaChartItem(areaSeries,m_chart);
+          //  m_animator->addAnimation(item);
         }
         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
         QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
@@ -214,11 +208,9 @@ void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
     }
     case QSeries::SeriesTypeScatter: {
 			QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
-			ScatterChartItem *item;
+			ScatterChartItem *item = new ScatterChartItem(scatterSeries, m_chart);
 			if(m_options.testFlag(QChart::SeriesAnimations)) {
-				item = new ScatterChartAnimationItem(scatterSeries,m_chart);
-			} else {
-				item = new ScatterChartItem(scatterSeries, m_chart);
+			    m_animator->addAnimation(item);
 			}
 			QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
 					item, SLOT(handleGeometryChanged(const QRectF&)));
@@ -262,11 +254,9 @@ void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
     case QSeries::SeriesTypeSpline: {
 
 			QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(series);
-			SplineChartItem* item;
+			SplineChartItem* item  = new SplineChartItem(splineSeries, m_chart);
 			if(m_options.testFlag(QChart::SeriesAnimations)) {
-				item = new SplineChartAnimationItem(splineSeries, m_chart);
-			} else {
-				item = new SplineChartItem(splineSeries, m_chart);
+			    m_animator->addAnimation(item);
 			}
 			QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), item, SLOT(handleGeometryChanged(const QRectF&)));
 			QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
@@ -290,6 +280,8 @@ void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
 void ChartPresenter::handleSeriesRemoved(QSeries* series)
 {
     ChartItem* item = m_chartItems.take(series);
+    Q_ASSERT(item);
+    if(m_animator) m_animator->removeAnimation(item);
     delete item;
 }
 
@@ -327,6 +319,10 @@ void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
 
         m_options=options;
 
+        if(m_options!=QChart::NoAnimation && !m_animator) {
+            m_animator= new ChartAnimator(this);
+        }
+
         //recreate elements
         QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
         QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
@@ -340,6 +336,7 @@ void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             handleSeriesAdded(series,m_dataset->domain(series));
         }
     }
+
 }
 
 void ChartPresenter::zoomIn()
diff --git a/src/chartpresenter_p.h b/src/chartpresenter_p.h
index f7a4cd4..361a7f5 100644
--- a/src/chartpresenter_p.h
+++ b/src/chartpresenter_p.h
@@ -11,10 +11,10 @@ QTCOMMERCIALCHART_BEGIN_NAMESPACE
 class ChartItem;
 class QSeries;
 class ChartDataSet;
-//class QChart;
 class Domain;
 class AxisItem;
 class ChartTheme;
+class ChartAnimator;
 
 class ChartPresenter: public QObject
 {
@@ -37,6 +37,7 @@ public:
     int margin() const;
 
     QRectF geometry() const;
+    ChartAnimator* animator() const {return m_animator;};
 
     void setChartTheme(QChart::ChartTheme theme);
     QChart::ChartTheme chartTheme();
@@ -65,6 +66,7 @@ signals:
 
 private:
     QChart* m_chart;
+    ChartAnimator* m_animator;
     ChartDataSet* m_dataset;
     ChartTheme *m_chartTheme;
     int m_zoomIndex;
diff --git a/src/linechart/linechartanimationitem.cpp b/src/linechart/linechartanimationitem.cpp
deleted file mode 100644
index 9c7820b..0000000
--- a/src/linechart/linechartanimationitem.cpp
+++ /dev/null
@@ -1,111 +0,0 @@
-#include "linechartanimationitem_p.h"
-#include "linechartitem_p.h"
-#include <QPropertyAnimation>
-#include <QTimer>
-
-Q_DECLARE_METATYPE(QVector<QPointF>)
-
-QTCOMMERCIALCHART_BEGIN_NAMESPACE
-
-const static int duration = 500;
-
-LineChartAnimationItem::LineChartAnimationItem(QLineSeries* series,QGraphicsItem *parent):
-LineChartItem(series,parent),
-m_animation(new LineChartAnimatator(this,this)),
-m_dirty(false)
-{
-}
-
-LineChartAnimationItem::~LineChartAnimationItem()
-{
-}
-
-void LineChartAnimationItem::updatePoints(QVector<QPointF>& newPoints)
-{
-    QVector<QPointF> oldPoints = points();
-    LineChartItem::updatePoints(newPoints);
-
-    if(newPoints.count()==0) return;
-    oldPoints.resize(newPoints.size());
-
-    if(m_animation->state()!=QAbstractAnimation::Stopped){
-       m_animation->stop();
-    }
-
-    m_animation->setDuration(duration);
-    m_animation->setEasingCurve(QEasingCurve::InOutBack);
-    m_animation->setKeyValueAt(0.0, qVariantFromValue(oldPoints));
-    m_animation->setKeyValueAt(1.0, qVariantFromValue(newPoints));
-    QTimer::singleShot(0,m_animation,SLOT(start()));
-
-    m_points = newPoints;
-    m_dirty=false;
-
-}
-
-void LineChartAnimationItem::updatePoint(int index,QPointF& newPoint)
-{
-
-    if(m_animation->state()!=QAbstractAnimation::Stopped){
-       m_animation->stop();
-       m_dirty=true;
-    }
-
-    if(m_dirty){
-    	m_points=points();
-    	m_dirty=false;
-    }
-
-    LineChartItem::updatePoint(index,newPoint);
-
-    m_animation->setDuration(duration);
-    m_animation->setEasingCurve(QEasingCurve::InOutBack);
-    m_animation->setKeyValueAt(0.0, qVariantFromValue(m_points));
-    m_animation->setKeyValueAt(1.0, qVariantFromValue( points()));
-
-    QTimer::singleShot(0,this,SLOT(startAnimation()));
-
-
-}
-
-void LineChartAnimationItem::startAnimation()
-{
-	 m_dirty=true;
-	 m_animation->start();
-}
-
-LineChartAnimatator::LineChartAnimatator(LineChartAnimationItem *item , QObject *parent):QVariantAnimation(parent),
-    m_item(item)
-{
-}
-
-LineChartAnimatator::~LineChartAnimatator()
-{
-}
-
-QVariant LineChartAnimatator::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const
-{
-	QVector<QPointF> startVector = qVariantValue<QVector<QPointF> >(start);
-	QVector<QPointF> endVecotr = qVariantValue<QVector<QPointF> >(end);
-	QVector<QPointF> result;
-    Q_ASSERT(startVector.count() == endVecotr.count());
-
-    for(int i =0 ;i< startVector.count();i++){
-           qreal x = startVector[i].x() + ((endVecotr[i].x()- startVector[i].x()) * progress);//qBound(0.0, progress, 1.0));
-           qreal y = startVector[i].y() + ((endVecotr[i].y()- startVector[i].y()) * progress);//qBound(0.0, progress, 1.0));
-           result << QPointF(x,y);
-    }
-    return qVariantFromValue(result);
-}
-
-void LineChartAnimatator::updateCurrentValue (const QVariant & value )
-{
-	QVector<QPointF> vector = qVariantValue<QVector<QPointF> >(value);
-	if(state()!=QAbstractAnimation::Stopped){ //workaround
-    m_item->setGeometry(vector);
-	}
-}
-
-#include "moc_linechartanimationitem_p.cpp"
-
-QTCOMMERCIALCHART_END_NAMESPACE
diff --git a/src/linechart/linechartanimationitem_p.h b/src/linechart/linechartanimationitem_p.h
deleted file mode 100644
index 17ccfc0..0000000
--- a/src/linechart/linechartanimationitem_p.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef LINECHARTANIMATIONITEM_P_H_
-#define LINECHARTANIMATIONITEM_P_H_
-
-#include "qchartglobal.h"
-#include "linechartitem_p.h"
-#include "domain_p.h"
-#include <QVariantAnimation>
-
-QTCOMMERCIALCHART_BEGIN_NAMESPACE
-
-class LineChartAnimatator;
-
-class LineChartAnimationItem : public LineChartItem {
-
-	Q_OBJECT
-
-public:
-	LineChartAnimationItem(QLineSeries *series, QGraphicsItem *parent = 0);
-	virtual ~LineChartAnimationItem();
-
-protected:
-	 virtual void updatePoints(QVector<QPointF>& newPoints);
-	 virtual void updatePoint(int index,QPointF& newPoint);
-
-private slots:
-	void startAnimation();
-
-private:
-    LineChartAnimatator *m_animation;
-    QVector<QPointF> m_points;
-    bool m_dirty;
-};
-
-class LineChartAnimatator: public QVariantAnimation
-{
-public:
-    LineChartAnimatator(LineChartAnimationItem *item, QObject *parent = 0 );
-    ~LineChartAnimatator();
-
-protected:
-    QVariant interpolated(const QVariant &start, const QVariant & end, qreal progress ) const;
-    void updateCurrentValue (const QVariant & value );
-
-private:
-    LineChartAnimationItem* m_item;
-};
-
-QTCOMMERCIALCHART_END_NAMESPACE
-
-#endif
diff --git a/src/linechart/linechartitem_p.h b/src/linechart/linechartitem_p.h
index 7fd6489..fb47b00 100644
--- a/src/linechart/linechartitem_p.h
+++ b/src/linechart/linechartitem_p.h
@@ -3,12 +3,10 @@
 
 #include "qchartglobal.h"
 #include "xychartitem_p.h"
-#include "xychartanimationitem_p.h"
 #include <QPen>
 
 QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
-class ChartPresenter;
 class QLineSeries;
 
 class LineChartItem :  public XYChartItem
@@ -43,12 +41,8 @@ private:
     QRectF m_rect;
     QPen m_pen;
 
-    template<class,class> friend class XYChartAnimator;
-
 };
 
-typedef XYChartAnimationItem<LineChartItem,QLineSeries> LineChartAnimationItem;
-
 QTCOMMERCIALCHART_END_NAMESPACE
 
 #endif
diff --git a/src/scatterseries/scatterchartitem_p.h b/src/scatterseries/scatterchartitem_p.h
index feaf6c9..f63f117 100644
--- a/src/scatterseries/scatterchartitem_p.h
+++ b/src/scatterseries/scatterchartitem_p.h
@@ -3,7 +3,6 @@
 
 #include "qchartglobal.h"
 #include "xychartitem_p.h"
-#include "xychartanimationitem_p.h"
 #include <QGraphicsItem>
 #include <QPen>
 
@@ -45,11 +44,8 @@ private:
     int m_size;
     QRectF m_rect;
 
-    template<class,class> friend class XYChartAnimator;
 };
 
-typedef XYChartAnimationItem<ScatterChartItem,QScatterSeries> ScatterChartAnimationItem;
-
 QTCOMMERCIALCHART_END_NAMESPACE
 
 #endif // SCATTERPRESENTER_H
diff --git a/src/splinechart/splinechartitem_p.h b/src/splinechart/splinechartitem_p.h
index 01eaa5a..7a4e44d 100644
--- a/src/splinechart/splinechartitem_p.h
+++ b/src/splinechart/splinechartitem_p.h
@@ -3,7 +3,6 @@
 
 #include "qsplineseries.h"
 #include "xychartitem_p.h"
-#include "xychartanimationitem_p.h"
 #include <QGraphicsItem>
 
 QTCOMMERCIALCHART_BEGIN_NAMESPACE
@@ -37,11 +36,8 @@ private:
     QRectF m_rect;
     QPen m_pen;
 
-    template<class,class> friend class XYChartAnimator;
 };
 
-typedef XYChartAnimationItem<SplineChartItem,QSplineSeries> SplineChartAnimationItem;
-
 QTCOMMERCIALCHART_END_NAMESPACE
 
 #endif // SPLINECHARTITEM_P_H
diff --git a/src/src.pro b/src/src.pro
index 413d92a..8182d27 100644
--- a/src/src.pro
+++ b/src/src.pro
@@ -27,7 +27,8 @@ PUBLIC_HEADERS += \
     qseries.h \
     qchartview.h \
     qlegend.h
-
+    
+include(animations/animations.pri)    
 include(axis/axis.pri)
 include(xychart/xychart.pri)
 include(linechart/linechart.pri)
diff --git a/src/xychart/xychart.pri b/src/xychart/xychart.pri
index 97dca93..ee2164d 100644
--- a/src/xychart/xychart.pri
+++ b/src/xychart/xychart.pri
@@ -6,9 +6,8 @@ SOURCES += \
     $$PWD/qxyseries.cpp  
     
 PRIVATE_HEADERS += \
-    $$PWD/xychartitem_p.h \
-    $$PWD/xychartanimationitem_p.h \
-    $$PWD/xychartanimator_p.h
+    $$PWD/xychartitem_p.h 
+
     
 PUBLIC_HEADERS += \    
     $$PWD/qxyseries.h  
\ No newline at end of file
diff --git a/src/xychart/xychartanimationitem_p.h b/src/xychart/xychartanimationitem_p.h
deleted file mode 100644
index 4b1b88f..0000000
--- a/src/xychart/xychartanimationitem_p.h
+++ /dev/null
@@ -1,107 +0,0 @@
-#ifndef XYCHARTANIMATIONITEM_P_H_
-#define XYCHARTANIMATIONITEM_P_H_
-#include "qchartglobal.h"
-#include "xychartanimator_p.h"
-#include <QPointF>
-#include <QTimer>
-#include <QGraphicsItem>
-
-Q_DECLARE_METATYPE(QVector<QPointF>)
-
-QTCOMMERCIALCHART_BEGIN_NAMESPACE
-
-
-const static int duration = 1000;
-
-template <class T , class U>
-class XYChartAnimationItem : public T {
-
-public:
-	XYChartAnimationItem(U *series, QGraphicsItem *parent = 0);
-	virtual ~XYChartAnimationItem();
-
-	void animationStarted();
-
-protected:
-	 virtual void updatePoints(QVector<QPointF>& newPoints);
-	 virtual void updatePoint(QVector<QPointF>& newPoints);
-
-private:
-    XYChartAnimator<T,U> *m_animation;
-    QVector<QPointF> m_points;
-    bool m_dirty;
-};
-
-template <class T, class U>
-XYChartAnimationItem<T,U>::XYChartAnimationItem(U *series,QGraphicsItem *parent):
-T(series,parent),
-m_animation(new XYChartAnimator<T,U>(this,this)),
-m_dirty(false)
-{
-}
-
-template <class T, class U>
-XYChartAnimationItem<T,U>::~XYChartAnimationItem()
-{
-}
-
-template <class T, class U>
-void XYChartAnimationItem<T,U>::updatePoints(QVector<QPointF>& newPoints)
-{
-    QVector<QPointF> oldPoints = T::points();
-
-    if(newPoints.count()==0) return;
-
-    bool empty = oldPoints.count()==0;
-    oldPoints.resize(newPoints.size());
-
-    if(m_animation->state()!=QAbstractAnimation::Stopped){
-       m_animation->stop();
-    }
-
-    m_animation->setDuration(duration);
-    if(!empty)
-        m_animation->setAnimationType(XYChartAnimator<T,U>::MoveDownAnimation);
-    else
-        m_animation->setAnimationType(XYChartAnimator<T,U>::LineDrawAnimation);
-    m_animation->setEasingCurve(QEasingCurve::OutQuart);
-    m_animation->setKeyValueAt(0.0, qVariantFromValue(oldPoints));
-    m_animation->setKeyValueAt(1.0, qVariantFromValue(newPoints));
-    QTimer::singleShot(0,m_animation,SLOT(start()));
-
-    m_points = newPoints;
-    m_dirty=false;
-}
-
-template <class T, class U>
-void XYChartAnimationItem<T,U>::updatePoint(QVector<QPointF>& newPoints)
-{
-
-	if(m_animation->state()!=QAbstractAnimation::Stopped) {
-		m_animation->stop();
-		m_dirty=true;
-	}
-
-	if(m_dirty) {
-		m_points=newPoints;
-		m_dirty=false;
-	}
-
-    m_animation->setDuration(duration);
-    m_animation->setAnimationType(XYChartAnimator<T,U>::MoveDownAnimation);
-    m_animation->setEasingCurve(QEasingCurve::OutQuart);
-    m_animation->setKeyValueAt(0.0, qVariantFromValue(m_points));
-    m_animation->setKeyValueAt(1.0, qVariantFromValue(newPoints));
-
-    QTimer::singleShot(0,m_animation,SLOT(start()));
-}
-
-template <class T, class U>
-void XYChartAnimationItem<T,U>::animationStarted()
-{
-	m_dirty=true;
-}
-
-QTCOMMERCIALCHART_END_NAMESPACE
-
-#endif
diff --git a/src/xychart/xychartitem.cpp b/src/xychart/xychartitem.cpp
index cf70d6a..31ac314 100644
--- a/src/xychart/xychartitem.cpp
+++ b/src/xychart/xychartitem.cpp
@@ -1,6 +1,7 @@
 #include "xychartitem_p.h"
 #include "qxyseries.h"
 #include "chartpresenter_p.h"
+#include "chartanimator_p.h"
 #include <QPainter>
 
 
@@ -8,7 +9,7 @@ QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
 //TODO: optimize : remove points which are not visible
 
-XYChartItem::XYChartItem(QXYSeries* series,QGraphicsItem *parent):ChartItem(parent),
+XYChartItem::XYChartItem(QXYSeries* series, QGraphicsItem *parent):ChartItem(parent),
 m_minX(0),
 m_maxX(0),
 m_minY(0),
@@ -57,7 +58,11 @@ QVector<QPointF> XYChartItem::calculateGeometryPoints() const
 
 void XYChartItem::updatePoints(QVector<QPointF>& points)
 {
-    setGeometry(points);
+    if(m_animator){
+       m_animator->applyLayout(this,points);
+    }
+       else  setGeometry(points);
+
 }
 
 void XYChartItem::updatePoint(QVector<QPointF>& points)
diff --git a/src/xychart/xychartitem_p.h b/src/xychart/xychartitem_p.h
index 7047492..7fde2d7 100644
--- a/src/xychart/xychartitem_p.h
+++ b/src/xychart/xychartitem_p.h
@@ -14,7 +14,7 @@ class XYChartItem :  public QObject , public ChartItem
 {
      Q_OBJECT
 public:
-     explicit XYChartItem(QXYSeries* series,QGraphicsItem *parent = 0);
+     explicit XYChartItem(QXYSeries* series, QGraphicsItem *parent = 0);
     ~ XYChartItem(){};
 
     QVector<QPointF> points() const {return m_points;}
@@ -28,15 +28,14 @@ public slots:
     void handleGeometryChanged(const QRectF& size);
 
 protected:
-    virtual void updatePoints(QVector<QPointF>& points);
-    virtual void updatePoint(QVector<QPointF>& points);
     virtual void setGeometry(QVector<QPointF>& points);
-
     QPointF calculateGeometryPoint(const QPointF& point) const;
     QPointF calculateGeometryPoint(int index) const;
     QVector<QPointF> calculateGeometryPoints() const;
 
 private:
+    void updatePoints(QVector<QPointF>& points);
+    void updatePoint(QVector<QPointF>& points);
     inline bool isEmpty();
 
 private:
@@ -49,7 +48,7 @@ private:
     QRectF m_clipRect;
     QVector<QPointF> m_points;
 
-    template<class,class> friend class XYChartAnimator;
+    friend class XYAnimation;
 
 };