diff --git a/src/animations/chartanimation_p.h b/src/animations/chartanimation_p.h
index 78e0b79..0e855e8 100644
--- a/src/animations/chartanimation_p.h
+++ b/src/animations/chartanimation_p.h
@@ -31,14 +31,7 @@ const static int ChartAnimationDuration = 1000;
 class ChartAnimation: public QVariantAnimation
 {
 public:
-    enum Animation { LineDrawAnimation, MoveDownAnimation, MoveUpAnimation };
-    ChartAnimation(QObject *parent = 0):QVariantAnimation(parent), m_type(MoveDownAnimation){}
-    void setAnimationType(Animation type){
-        m_type=type;
-    }
-protected:
-    Animation m_type;
-
+    ChartAnimation(QObject *parent = 0):QVariantAnimation(parent){};
 };
 
 QTCOMMERCIALCHART_END_NAMESPACE
diff --git a/src/animations/chartanimator.cpp b/src/animations/chartanimator.cpp
index 8360f29..c49cd2a 100644
--- a/src/animations/chartanimator.cpp
+++ b/src/animations/chartanimator.cpp
@@ -58,42 +58,6 @@ void ChartAnimator::addAnimation(ChartAxis *item)
     item->setAnimator(this);
 }
 
-void ChartAnimator::addAnimation(SplineChartItem *item)
-{
-    ChartAnimation *animation = m_animations.value(item);
-
-    if (!animation) {
-        animation = new SplineAnimation(item);
-        m_animations.insert(item, animation);
-    }
-
-    item->setAnimator(this);
-}
-
-void ChartAnimator::addAnimation(ScatterChartItem *item)
-{
-    ChartAnimation *animation = m_animations.value(item);
-
-    if (!animation) {
-        animation = new XYAnimation(item);
-        m_animations.insert(item, animation);
-    }
-
-    item->setAnimator(this);
-}
-
-void ChartAnimator::addAnimation(LineChartItem *item)
-{
-    ChartAnimation *animation = m_animations.value(item);
-
-    if (!animation) {
-        animation = new XYAnimation(item);
-        m_animations.insert(item, animation);
-    }
-
-    item->setAnimator(this);
-}
-
 void ChartAnimator::addAnimation(PieChartItem *item)
 {
     ChartAnimation *animation = m_animations.value(item);
@@ -194,61 +158,6 @@ void ChartAnimator::updateLayout(ChartAxis *item , QVector<qreal> &newLayout)
     QTimer::singleShot(0, animation, SLOT(start()));
 }
 
-void ChartAnimator::updateLayout(SplineChartItem *item, QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldControlPoints, QVector<QPointF> &newControlPoints, int index)
-{
-    SplineAnimation *animation = static_cast<SplineAnimation *>(m_animations.value(item));
-
-    Q_ASSERT(animation);
-
-    if (newPoints.count() < 2 || newControlPoints.count() < 2)
-        return;
-
-    bool empty = oldPoints.count() == 0;
-
-
-    if (animation->state() != QAbstractAnimation::Stopped)
-        animation->stop();
-
-    animation->setDuration(ChartAnimationDuration);
-    if (!empty)
-        animation->setAnimationType(ChartAnimation::MoveDownAnimation);
-    else
-        animation->setAnimationType(ChartAnimation::LineDrawAnimation);
-
-    animation->setEasingCurve(QEasingCurve::OutQuart);
-    animation->setValues(oldPoints, newPoints, oldControlPoints, newControlPoints, index);
-
-    QTimer::singleShot(0, animation, SLOT(start()));
-}
-
-
-void ChartAnimator::updateLayout(XYChartItem *item, QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
-{
-    XYAnimation *animation = static_cast<XYAnimation *>(m_animations.value(item));
-
-    Q_ASSERT(animation);
-
-    if (newPoints.count() == 0)
-        return;
-
-    bool empty = oldPoints.count() == 0;
-
-
-    if (animation->state() != QAbstractAnimation::Stopped)
-        animation->stop();
-
-    animation->setDuration(ChartAnimationDuration);
-    if (!empty)
-        animation->setAnimationType(ChartAnimation::MoveDownAnimation);
-    else
-        animation->setAnimationType(ChartAnimation::LineDrawAnimation);
-
-    animation->setEasingCurve(QEasingCurve::OutQuart);
-    animation->setValues(oldPoints, newPoints, index);
-
-    QTimer::singleShot(0, animation, SLOT(start()));
-}
-
 void ChartAnimator::addAnimation(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData, bool startupAnimation)
 {
     PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
@@ -287,6 +196,16 @@ void ChartAnimator::setState(State state, const QPointF &point)
     m_point = point;
 }
 
+void ChartAnimator::startAnimation(XYAnimation* animation)
+{
+    Q_ASSERT(animation);
+    if (animation->state() != QAbstractAnimation::Stopped)
+    animation->stop();
+    animation->setDuration(ChartAnimationDuration);
+    animation->setEasingCurve(QEasingCurve::OutQuart);
+    QTimer::singleShot(0, animation, SLOT(start()));
+}
+
 #include "moc_chartanimator_p.cpp"
 
 QTCOMMERCIALCHART_END_NAMESPACE
diff --git a/src/animations/chartanimator_p.h b/src/animations/chartanimator_p.h
index 0e5db5f..d22d89f 100644
--- a/src/animations/chartanimator_p.h
+++ b/src/animations/chartanimator_p.h
@@ -36,6 +36,7 @@ class SplineChartItem;
 class ScatterChartItem;
 class LineChartItem;
 class XYChartItem;
+class XYAnimation;
 
 class ChartAnimator : public QObject
 {
@@ -48,15 +49,10 @@ public:
 
     void addAnimation(ChartAxis *item);
     void addAnimation(PieChartItem *item);
-    void addAnimation(ScatterChartItem *item);
-    void addAnimation(LineChartItem *item);
-    void addAnimation(SplineChartItem *item);
     void addAnimation(BarChartItem *item);
     void removeAnimation(Chart *item);
 
     void animationStarted();
-    void updateLayout(XYChartItem *item, QVector<QPointF> &oldLayout, QVector<QPointF> &newLayout, int index);
-    void updateLayout(SplineChartItem *item, QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldControlPoints, QVector<QPointF> &newContorlPoints, int index);
     void updateLayout(ChartAxis *item, QVector<qreal> &layout);
 
     void addAnimation(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData, bool isEmpty);
@@ -67,6 +63,8 @@ public:
 
     void setState(State state,const QPointF &point = QPointF());
 
+    void startAnimation(XYAnimation* animation);
+
 private:
      QMap<Chart *, ChartAnimation *> m_animations;
      State m_state;
diff --git a/src/animations/splineanimation.cpp b/src/animations/splineanimation.cpp
index 77e2e67..700778a 100644
--- a/src/animations/splineanimation.cpp
+++ b/src/animations/splineanimation.cpp
@@ -27,7 +27,7 @@ Q_DECLARE_METATYPE(SplineVector)
 
 QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
-SplineAnimation::SplineAnimation(SplineChartItem* item):ChartAnimation(item),
+SplineAnimation::SplineAnimation(SplineChartItem* item):XYAnimation(item),
     m_item(item),
     m_dirty(true)
 {
@@ -82,7 +82,6 @@ void SplineAnimation::setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &n
         newPair.second=newControlPoints;
         setKeyValueAt(0.0, qVariantFromValue(m_oldSpline));
         setKeyValueAt(1.0, qVariantFromValue(newPair));
-
     }
 }
 
@@ -93,8 +92,7 @@ QVariant SplineAnimation::interpolated(const QVariant &start, const QVariant &en
     SplineVector endPair =  qVariantValue< SplineVector >(end);
     SplineVector result;
 
-
-    switch (m_type) {
+    switch (animationType()) {
 
     case MoveDownAnimation: {
         if (startPair.first.count() != endPair.first.count())
@@ -130,7 +128,7 @@ QVariant SplineAnimation::interpolated(const QVariant &start, const QVariant &en
     }
         break;
     default:
-        qWarning() << "Unknow type of animation";
+        qWarning() << "Unknown type of animation";
         break;
     }
 
@@ -142,7 +140,9 @@ void SplineAnimation::updateCurrentValue (const QVariant &value )
     if (state() != QAbstractAnimation::Stopped) { //workaround
         m_dirty = true;
         QPair<QVector<QPointF >, QVector<QPointF > > pair = qVariantValue< QPair< QVector<QPointF>, QVector<QPointF> > >(value);
-        m_item->setLayout(pair.first, pair.second);
+        m_item->setGeometryPoints(pair.first);
+        m_item->setControlGeometryPoints(pair.second);
+        m_item->updateGeometry();
     }
 }
 
diff --git a/src/animations/splineanimation_p.h b/src/animations/splineanimation_p.h
index d23dd9b..6f1d8da 100644
--- a/src/animations/splineanimation_p.h
+++ b/src/animations/splineanimation_p.h
@@ -20,7 +20,7 @@
 
 #ifndef SPLINEANIMATION_P_H
 #define SPLINEANIMATION_P_H
-#include "chartanimation_p.h"
+#include "xyanimation_p.h"
 #include <QPointF>
 
 typedef  QPair<QVector<QPointF >, QVector<QPointF > >  SplineVector;
@@ -29,10 +29,9 @@ QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
 class SplineChartItem;
 
-class SplineAnimation : public ChartAnimation
+class SplineAnimation : public XYAnimation
 {
 public:
-
     SplineAnimation(SplineChartItem *item);
     ~SplineAnimation();
     void setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldContorlPoints, QVector<QPointF> &newControlPoints, int index);
diff --git a/src/animations/xyanimation.cpp b/src/animations/xyanimation.cpp
index d6ed03c..8eedc2a 100644
--- a/src/animations/xyanimation.cpp
+++ b/src/animations/xyanimation.cpp
@@ -28,7 +28,8 @@ QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
 XYAnimation::XYAnimation(XYChartItem *item):ChartAnimation(item),
     m_item(item),
-    m_dirty(false)
+    m_dirty(false),
+    m_type(MoveDownAnimation)
 {
 }
 
@@ -36,6 +37,11 @@ XYAnimation::~XYAnimation()
 {
 }
 
+void XYAnimation::setAnimationType(Animation type)
+{
+    m_type=type;
+}
+
 void XYAnimation::setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
 {
     int x = oldPoints.count();
@@ -103,7 +109,8 @@ void XYAnimation::updateCurrentValue (const QVariant &value)
     if(state()!=QAbstractAnimation::Stopped){ //workaround
         m_dirty = true;
         QVector<QPointF> vector = qVariantValue<QVector<QPointF> >(value);
-        m_item->setLayout(vector);
+        m_item->setGeometryPoints(vector);
+        m_item->updateGeometry();
     }
 }
 
diff --git a/src/animations/xyanimation_p.h b/src/animations/xyanimation_p.h
index eed6803..d7b987a 100644
--- a/src/animations/xyanimation_p.h
+++ b/src/animations/xyanimation_p.h
@@ -35,6 +35,8 @@ public:
     XYAnimation(XYChartItem *item);
     ~XYAnimation();
     void setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index);
+    void setAnimationType(Animation type);
+    Animation animationType() const { return m_type; };
 
 protected:
     QVariant interpolated(const QVariant &start, const QVariant &end, qreal progress ) const;
@@ -44,6 +46,7 @@ private:
     XYChartItem *m_item;
     QVector<QPointF> m_oldPoints;
     bool m_dirty;
+    Animation m_type;
 };
 
 QTCOMMERCIALCHART_END_NAMESPACE
diff --git a/src/areachart/areachartitem.cpp b/src/areachart/areachartitem.cpp
index 7a776e9..636f98a 100644
--- a/src/areachart/areachartitem.cpp
+++ b/src/areachart/areachartitem.cpp
@@ -43,8 +43,8 @@ AreaChartItem::AreaChartItem(QAreaSeries *areaSeries, ChartPresenter *presenter)
     if (m_series->lowerSeries())
         m_lower = new AreaBoundItem(this,m_series->lowerSeries());
 
-    connect(m_series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
-    connect(this,SIGNAL(clicked(QPointF)),areaSeries,SIGNAL(clicked(QPointF)));
+    QObject::connect(m_series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
+    QObject::connect(this,SIGNAL(clicked(QPointF)),areaSeries,SIGNAL(clicked(QPointF)));
 
     handleUpdated();
 }
@@ -125,9 +125,9 @@ void AreaChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *opt
     painter->drawPath(m_path);
     if (m_pointsVisible) {
            painter->setPen(m_pointPen);
-           painter->drawPoints(m_upper->points());
+           painter->drawPoints(m_upper->geometryPoints());
            if (m_lower)
-               painter->drawPoints(m_lower->points());
+               painter->drawPoints(m_lower->geometryPoints());
     }
     painter->restore();
 }
diff --git a/src/areachart/areachartitem_p.h b/src/areachart/areachartitem_p.h
index 551bbf1..dbc7af3 100644
--- a/src/areachart/areachartitem_p.h
+++ b/src/areachart/areachartitem_p.h
@@ -78,8 +78,8 @@ public:
     AreaBoundItem(AreaChartItem *item,QLineSeries *lineSeries) : LineChartItem(lineSeries, 0), m_item(item) {}
     ~AreaBoundItem() {}
 
-    void setLayout(QVector<QPointF> &points) {
-        LineChartItem::setLayout(points);
+    void updateGeometry() {
+        LineChartItem::updateGeometry();
         m_item->updatePath();
     }
 
diff --git a/src/areachart/qareaseries.cpp b/src/areachart/qareaseries.cpp
index d18345a..8a390d0 100644
--- a/src/areachart/qareaseries.cpp
+++ b/src/areachart/qareaseries.cpp
@@ -284,8 +284,12 @@ Chart* QAreaSeriesPrivate::createGraphics(ChartPresenter* presenter)
 
     AreaChartItem* area = new AreaChartItem(q,presenter);
     if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
-        presenter->animator()->addAnimation(area->upperLineItem());
-        if(q->lowerSeries())  presenter->animator()->addAnimation(area->lowerLineItem());
+        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;
diff --git a/src/chart.cpp b/src/chart.cpp
index 405be2c..ff949b0 100644
--- a/src/chart.cpp
+++ b/src/chart.cpp
@@ -20,14 +20,14 @@
 
 #include "chart_p.h"
 #include "chartpresenter_p.h"
-#include <QDebug>
+#include "domain_p.h"
 
 QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
-
 Chart::Chart(ChartPresenter *presenter):QObject(presenter),
     m_animator(0),
-    m_presenter(presenter)
+    m_presenter(presenter),
+    m_domain(0)
 {
 }
 
@@ -41,11 +41,27 @@ 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);
@@ -61,22 +77,6 @@ void Chart::handleDomainChanged(qreal minX,qreal maxX,qreal minY,qreal maxY)
     qWarning()<<"Slot not implemented";
 }
 
-void Chart::rangeXChanged(qreal min, qreal max, int tickXCount)
-{
-    Q_UNUSED(min);
-    Q_UNUSED(max);
-    Q_UNUSED(tickXCount);
-    qWarning()<<"Slot not implemented";
-}
-
-void Chart::rangeYChanged(qreal min, qreal max, int tickYCount)
-{
-    Q_UNUSED(min);
-    Q_UNUSED(max);
-    Q_UNUSED(tickYCount);
-    qWarning()<<"Slot not implemented";
-}
-
 #include "moc_chart_p.cpp"
 
 QTCOMMERCIALCHART_END_NAMESPACE
diff --git a/src/chart_p.h b/src/chart_p.h
index 584299b..41017c2 100644
--- a/src/chart_p.h
+++ b/src/chart_p.h
@@ -29,6 +29,8 @@ QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
 class ChartAnimator;
 class ChartPresenter;
+class ChartAnimation;
+class Domain;
 
 class Chart: public QObject
 {
@@ -39,16 +41,19 @@ public:
 public Q_SLOTS:
     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 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
diff --git a/src/chartpresenter.cpp b/src/chartpresenter.cpp
index 6377360..8a5d0bd 100644
--- a/src/chartpresenter.cpp
+++ b/src/chartpresenter.cpp
@@ -134,7 +134,7 @@ void ChartPresenter::handleAxisAdded(QAxis* axis,Domain* domain)
 
     QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
     //initialize
-    item->handleGeometryChanged(m_chartRect);
+    if(m_chartRect.isValid()) item->handleGeometryChanged(m_chartRect);
     m_axisItems.insert(axis, item);
 }
 
@@ -384,7 +384,7 @@ void ChartPresenter::updateLayout()
 
     legend->setGeometry(m_rect.adjusted(m_legendMargins.left(),m_legendMargins.top(),-m_legendMargins.right(),-m_legendMargins.bottom()));
 
-    if(m_chartRect!=chartRect){
+    if(m_chartRect!=chartRect && chartRect.isValid()){
         m_chartRect=chartRect;
         emit geometryChanged(m_chartRect);
     }
diff --git a/src/linechart/linechartitem.cpp b/src/linechart/linechartitem.cpp
index 2af123b..2951d63 100644
--- a/src/linechart/linechartitem.cpp
+++ b/src/linechart/linechartitem.cpp
@@ -48,17 +48,16 @@ QPainterPath LineChartItem::shape() const
     return m_path;
 }
 
-void LineChartItem::setLayout(QVector<QPointF>& points)
+void LineChartItem::updateGeometry()
 {
+    const QVector<QPointF>& points = geometryPoints();
+
     if(points.size()==0)
     {
         m_path = QPainterPath();
-        XYChartItem::setLayout(points);
         return;
     }
 
-    QList<QGraphicsItem*> items = m_items.childItems();
-
     QPainterPath linePath(points.at(0));
 
     for(int i=1; i< points.size();i++) {
@@ -68,9 +67,6 @@ void LineChartItem::setLayout(QVector<QPointF>& points)
     prepareGeometryChange();
     m_path = linePath;
     m_rect = linePath.boundingRect();
-
-    XYChartItem::setLayout(points);
-
 }
 
 void LineChartItem::handleUpdated()
@@ -95,7 +91,7 @@ void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *opt
     painter->drawPath(m_path);
     if(m_pointsVisible){
     	painter->setPen(m_pointPen);
-    	painter->drawPoints(points());
+    	painter->drawPoints(geometryPoints());
     }
     painter->restore();
 }
diff --git a/src/linechart/linechartitem_p.h b/src/linechart/linechartitem_p.h
index a592587..fe8c167 100644
--- a/src/linechart/linechartitem_p.h
+++ b/src/linechart/linechartitem_p.h
@@ -44,13 +44,11 @@ public:
 
 public Q_SLOTS:
     void handleUpdated();
-
 protected:
-    void setLayout(QVector<QPointF>& points);
+    void updateGeometry();
 
 private:
     QLineSeries* m_series;
-    QGraphicsItemGroup m_items;
     QPainterPath m_path;
     QRectF m_rect;
     QPen m_linePen;
diff --git a/src/linechart/qlineseries.cpp b/src/linechart/qlineseries.cpp
index 9898c9a..3954496 100644
--- a/src/linechart/qlineseries.cpp
+++ b/src/linechart/qlineseries.cpp
@@ -111,7 +111,8 @@ Chart* QLineSeriesPrivate::createGraphics(ChartPresenter* presenter)
     Q_Q(QLineSeries);
     LineChartItem* line = new LineChartItem(q,presenter);
     if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
-        presenter->animator()->addAnimation(line);
+        line->setAnimator(presenter->animator());
+        line->setAnimation(new XYAnimation(line));
     }
     presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
     return line;
diff --git a/src/scatterchart/qscatterseries.cpp b/src/scatterchart/qscatterseries.cpp
index ba2a355..bd9e94d 100644
--- a/src/scatterchart/qscatterseries.cpp
+++ b/src/scatterchart/qscatterseries.cpp
@@ -140,7 +140,8 @@ Chart* QScatterSeriesPrivate::createGraphics(ChartPresenter* presenter)
     Q_Q(QScatterSeries);
     ScatterChartItem *scatter = new ScatterChartItem(q,presenter);
     if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
-        presenter->animator()->addAnimation(scatter);
+        scatter->setAnimator(presenter->animator());
+        scatter->setAnimation(new XYAnimation(scatter));
     }
     presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
     return scatter;
diff --git a/src/scatterchart/scatterchartitem.cpp b/src/scatterchart/scatterchartitem.cpp
index e713225..b4d9a9f 100644
--- a/src/scatterchart/scatterchartitem.cpp
+++ b/src/scatterchart/scatterchartitem.cpp
@@ -101,12 +101,14 @@ void ScatterChartItem::markerSelected(Marker *marker)
     emit XYChartItem::clicked(marker->point());
 }
 
-void ScatterChartItem::setLayout(QVector<QPointF>& points)
+void ScatterChartItem::updateGeometry()
 {
+
+    const QVector<QPointF>& points = geometryPoints();
+
     if(points.size()==0)
     {
         deletePoints(m_items.childItems().count());
-        XYChartItem::setLayout(points);
         return;
     }
 
@@ -139,7 +141,6 @@ void ScatterChartItem::setLayout(QVector<QPointF>& points)
 
     prepareGeometryChange();
     m_rect = clipRect();
-    XYChartItem::setLayout(points);
 }
 
 
diff --git a/src/scatterchart/scatterchartitem_p.h b/src/scatterchart/scatterchartitem_p.h
index a6a26fe..96c4ee3 100644
--- a/src/scatterchart/scatterchartitem_p.h
+++ b/src/scatterchart/scatterchartitem_p.h
@@ -55,7 +55,7 @@ private:
     void deletePoints(int count);
 
 protected:
-    void setLayout(QVector<QPointF> &points);
+    void updateGeometry();
 
 private:
     QScatterSeries *m_series;
diff --git a/src/splinechart/qsplineseries.cpp b/src/splinechart/qsplineseries.cpp
index db68d34..610dfa1 100644
--- a/src/splinechart/qsplineseries.cpp
+++ b/src/splinechart/qsplineseries.cpp
@@ -254,8 +254,10 @@ Chart* QSplineSeriesPrivate::createGraphics(ChartPresenter* presenter)
     Q_Q(QSplineSeries);
     SplineChartItem* spline  = new SplineChartItem(q,presenter);
     if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
-        presenter->animator()->addAnimation(spline);
+        spline->setAnimator(presenter->animator());
+        spline->setAnimation(new SplineAnimation(spline));
     }
+
     presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
     return spline;
 }
diff --git a/src/splinechart/splinechartitem.cpp b/src/splinechart/splinechartitem.cpp
index 72a3fd8..c40bd95 100644
--- a/src/splinechart/splinechartitem.cpp
+++ b/src/splinechart/splinechartitem.cpp
@@ -30,7 +30,8 @@ QTCOMMERCIALCHART_BEGIN_NAMESPACE
 SplineChartItem::SplineChartItem(QSplineSeries *series, ChartPresenter *presenter) :
     XYChartItem(series, presenter),
     m_series(series),
-    m_pointsVisible(false)
+    m_pointsVisible(false),
+    m_animation(0)
 {
     setZValue(ChartPresenter::LineChartZValue);
     QObject::connect(m_series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
@@ -47,11 +48,27 @@ QPainterPath SplineChartItem::shape() const
     return m_path;
 }
 
-void SplineChartItem::updateLayout(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
+void SplineChartItem::setAnimation(SplineAnimation* animation)
+{
+    m_animation=animation;
+    XYChartItem::setAnimation(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){
+    if(newPoints.count()>=2) {
         controlPoints.resize(newPoints.count()*2-2);
     }
 
@@ -61,38 +78,35 @@ void SplineChartItem::updateLayout(QVector<QPointF> &oldPoints, QVector<QPointF>
     }
 
     if (controlPoints.count()<2) {
-        setLayout(newPoints,controlPoints);
+        setGeometryPoints(newPoints);
+        setControlGeometryPoints(controlPoints);
+        updateGeometry();
         return;
     }
 
-    if (animator()) {
-       animator()->updateLayout(this,oldPoints,newPoints,m_controlPoints,controlPoints,index);
-    } else {
-       setLayout(newPoints,controlPoints);
+    if (m_animation) {
+        m_animation->setValues(oldPoints,newPoints,m_controlPoints,controlPoints,index);
+        animator()->startAnimation(m_animation);
+    }
+    else {
+        setGeometryPoints(newPoints);
+        setControlGeometryPoints(controlPoints);
+        updateGeometry();
     }
 }
 
 QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
 {
-//    return XYChartItem::calculateGeometryPoint(m_series->controlPoint(index));
     return XYChartItem::calculateGeometryPoint(m_series->d_func()->controlPoint(index));
 }
 
-void SplineChartItem::setLayout(QVector<QPointF> &points)
+void SplineChartItem::updateGeometry()
 {
-    // Dummy implementation because of a bug in Clang compiler
-    if (points.size() < 2) {
-        m_path = QPainterPath();
-    }
-    XYChartItem::setLayout(points);
-}
+    const QVector<QPointF> &points = geometryPoints();
+    const QVector<QPointF> &controlPoints = controlGeometryPoints();
 
-void SplineChartItem::setLayout(QVector<QPointF> &points, QVector<QPointF> &controlPoints)
-{
     if ((points.size()<2) || (controlPoints.size()<2)) {
         m_path = QPainterPath();
-        XYChartItem::setLayout(points);
-        m_controlPoints=controlPoints;
         return;
     }
 
@@ -108,9 +122,6 @@ void SplineChartItem::setLayout(QVector<QPointF> &points, QVector<QPointF> &cont
     prepareGeometryChange();
     m_path = splinePath;
     m_rect = splinePath.boundingRect();
-    XYChartItem::setLayout(points);
-    m_controlPoints=controlPoints;
-
 }
 
 //handlers
@@ -130,14 +141,13 @@ void SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *o
 {
     Q_UNUSED(widget)
     Q_UNUSED(option)
-    qDebug()<<__FUNCTION__;
     painter->save();
     painter->setClipRect(clipRect());
     painter->setPen(m_linePen);
     painter->drawPath(m_path);
     if (m_pointsVisible) {
         painter->setPen(m_pointPen);
-        painter->drawPoints(points());
+        painter->drawPoints(geometryPoints());
     }
     painter->restore();
 }
diff --git a/src/splinechart/splinechartitem_p.h b/src/splinechart/splinechartitem_p.h
index 82edfea..f9f9c0d 100644
--- a/src/splinechart/splinechartitem_p.h
+++ b/src/splinechart/splinechartitem_p.h
@@ -23,6 +23,7 @@
 
 #include "qsplineseries.h"
 #include "xychartitem_p.h"
+#include "splineanimation_p.h"
 
 QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
@@ -37,13 +38,18 @@ public:
     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; }
+
 public Q_SLOTS:
     void handleUpdated();
 
 protected:
-    void setLayout(QVector<QPointF> &points);
-    void setLayout(QVector<QPointF> &points,QVector<QPointF> &controlPoints);
-    void updateLayout(QVector<QPointF> &oldPoints,QVector<QPointF> &newPoints,int index);
+    void updateGeometry();
+    void updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index);
 
 private:
     QPointF calculateGeometryControlPoint(int index) const;
@@ -56,6 +62,7 @@ private:
     QPen m_pointPen;
     bool m_pointsVisible;
     QVector<QPointF> m_controlPoints;
+    SplineAnimation* m_animation;
 
     friend class SplineAnimation;
 };
diff --git a/src/xychart/qxyseries.cpp b/src/xychart/qxyseries.cpp
index 3c00399..b310dec 100644
--- a/src/xychart/qxyseries.cpp
+++ b/src/xychart/qxyseries.cpp
@@ -407,6 +407,7 @@ void QXYSeriesPrivate::scaleDomain(Domain& domain)
 
     const QList<QPointF>& points = q->points();
 
+
     if(points.isEmpty()){
         minX=0.0;
         minY=0.0;
@@ -425,18 +426,6 @@ void QXYSeriesPrivate::scaleDomain(Domain& domain)
     }
 
     domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
-
-    if (!points.isEmpty()) {
-        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,tickXCount,tickYCount);
-    }
 }
 
 QList<LegendMarker*> QXYSeriesPrivate::createLegendMarker(QLegend* legend)
diff --git a/src/xychart/xychartitem.cpp b/src/xychart/xychartitem.cpp
index 42036cd..d117462 100644
--- a/src/xychart/xychartitem.cpp
+++ b/src/xychart/xychartitem.cpp
@@ -1,22 +1,22 @@
 /****************************************************************************
-**
-** 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$
-**
-****************************************************************************/
+ **
+ ** 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 "xychartitem_p.h"
 #include "qxyseries.h"
@@ -27,26 +27,42 @@
 #include <QGraphicsSceneMouseEvent>
 #include <QAbstractItemModel>
 #include "qxymodelmapper.h"
-
+#include <QDebug>
 
 QTCOMMERCIALCHART_BEGIN_NAMESPACE
 
 //TODO: optimize : remove points which are not visible
 
 XYChartItem::XYChartItem(QXYSeries *series, ChartPresenter *presenter):ChartItem(presenter),
-    m_minX(0),
-    m_maxX(0),
-    m_minY(0),
-    m_maxY(0),
-    m_series(series)
+m_minX(0),
+m_maxX(0),
+m_minY(0),
+m_maxY(0),
+m_series(series),
+m_animation(0)
+{
+    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(pointsAdded(int, int)),this,SLOT(handlePointsAdded(int, int)));
+    QObject::connect(series->d_func(),SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
+    QObject::connect(series->d_func(),SIGNAL(pointsRemoved(int, int)),this,SLOT(handlePointsRemoved(int, int)));
+    QObject::connect(series->d_func(),SIGNAL(reinitialized()),this,SLOT(handleReinitialized()));
+    QObject::connect(this,SIGNAL(clicked(QPointF)),series,SIGNAL(clicked(QPointF)));
+}
+
+void XYChartItem::setGeometryPoints(QVector<QPointF>& points)
+{
+    m_points = points;
+}
+
+void XYChartItem::setClipRect(const QRectF &rect)
+{
+    m_clipRect = rect;
+}
+
+void XYChartItem::setAnimation(XYAnimation* animation)
 {
-    connect(series->d_func(),SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
-    connect(series->d_func(),SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
-    connect(series->d_func(),SIGNAL(pointsAdded(int, int)),this,SLOT(handlePointsAdded(int, int)));
-    connect(series->d_func(),SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
-    connect(series->d_func(),SIGNAL(pointsRemoved(int, int)),this,SLOT(handlePointsRemoved(int, int)));
-    connect(series->d_func(),SIGNAL(reinitialized()),this,SLOT(handleReinitialized()));
-    connect(this,SIGNAL(clicked(QPointF)),series,SIGNAL(clicked(QPointF)));
+    m_animation=animation;
 }
 
 QPointF XYChartItem::calculateGeometryPoint(const QPointF &point) const
@@ -58,7 +74,6 @@ QPointF XYChartItem::calculateGeometryPoint(const QPointF &point) const
     return QPointF(x,y);
 }
 
-
 QPointF XYChartItem::calculateGeometryPoint(int index) const
 {
     const qreal deltaX = m_size.width()/(m_maxX-m_minX);
@@ -95,21 +110,22 @@ QPointF XYChartItem::calculateDomainPoint(const QPointF &point) const
     return QPointF(x,y);
 }
 
-void XYChartItem::updateLayout(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
+void XYChartItem::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
 {
-    if (animator()) {
-        animator()->updateLayout(this,oldPoints,newPoints,index);
-    } else {
-        setLayout(newPoints);
+    if (m_animation) {
+        m_animation->setValues(oldPoints, newPoints, index);
+        animator()->startAnimation(m_animation);
+    }
+    else {
+        setGeometryPoints(newPoints);
+        updateGeometry();
     }
 }
 
-void XYChartItem::setLayout(QVector<QPointF> &points)
+void XYChartItem::updateGeometry()
 {
-    m_points = points;
     update();
 }
-
 //handlers
 
 void XYChartItem::handlePointAdded(int index)
@@ -118,38 +134,45 @@ void XYChartItem::handlePointAdded(int index)
         Q_ASSERT(index<m_series->count());
         Q_ASSERT(index>=0);
     }
+
     QVector<QPointF> points = m_points;
     QPointF point;
     point = calculateGeometryPoint(index);
     points.insert(index, point);
-    updateLayout(m_points, points, index);
-    update();
+
+    if(m_animation) {
+        m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
+    }
+
+   updateChart(m_points,points,index);
 }
 
 void XYChartItem::handlePointsAdded(int start, int end)
-{    
+{
     if (m_series->model() == 0) {
         for (int i = start; i <= end; i++)
-            handlePointAdded(i);
-    } else {
+        handlePointAdded(i);
+    }
+    else {
         int mapFirst = m_series->modelMapper()->first();
         int mapCount = m_series->modelMapper()->count();
         if (mapCount != -1 && start >= mapFirst + mapCount) {
             return;
-        } else {
+        }
+        else {
             int addedCount = end - start + 1;
             if (mapCount != -1 && addedCount > mapCount)
-                addedCount = mapCount;
-            int first = qMax(start, mapFirst);  // get the index of the first item that will be added
-            int last = qMin(first + addedCount - 1, mapCount + mapFirst - 1);  // get the index of the last item that will be added
+            addedCount = mapCount;
+            int first = qMax(start, mapFirst); // get the index of the first item that will be added
+            int last = qMin(first + addedCount - 1, mapCount + mapFirst - 1);// get the index of the last item that will be added
             for (int i = first; i <= last; i++) {
                 handlePointAdded(i - mapFirst);
             }
             // the map is limited therefore the items that are now outside the map
             // need to be removed from the drawn points
             if (mapCount != -1 && m_points.size() > mapCount)
-                for (int i = m_points.size() - 1; i >= mapCount; i--)
-                    handlePointRemoved(i);
+            for (int i = m_points.size() - 1; i >= mapCount; i--)
+            handlePointRemoved(i);
         }
     }
 }
@@ -162,8 +185,12 @@ void XYChartItem::handlePointRemoved(int index)
     }
     QVector<QPointF> points = m_points;
     points.remove(index);
-    updateLayout(m_points, points, index);
-    update();
+
+    if(m_animation) {
+        m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
+    }
+
+    updateChart(m_points,points,index);
 }
 
 void XYChartItem::handlePointsRemoved(int start, int end)
@@ -172,42 +199,45 @@ void XYChartItem::handlePointsRemoved(int start, int end)
     Q_UNUSED(end)
     if (m_series->model() == 0) {
         for (int i = end; i >= start; i--)
-            handlePointRemoved(i);
-    } else {
+        handlePointRemoved(i);
+    }
+    else {
         // series uses model as a data source
         int mapFirst = m_series->modelMapper()->first();
         int mapCount = m_series->modelMapper()->count();
         int removedCount = end - start + 1;
         if (mapCount != -1 && start >= mapFirst + mapCount) {
             return;
-        } else {
-            int toRemove = qMin(m_points.size(), removedCount);     // first find how many items can actually be removed
-            int first = qMax(start, mapFirst);    // get the index of the first item that will be removed.
-            int last = qMin(first + toRemove - 1, m_points.size() + mapFirst - 1);    // get the index of the last item that will be removed.
+        }
+        else {
+            int toRemove = qMin(m_points.size(), removedCount); // first find how many items can actually be removed
+            int first = qMax(start, mapFirst);// get the index of the first item that will be removed.
+            int last = qMin(first + toRemove - 1, m_points.size() + mapFirst - 1);// get the index of the last item that will be removed.
             if (last - first == 0) {
                 for (int i = last; i >= first; i--) {
                     handlePointRemoved(i - mapFirst);
 
                 }
-            } else {
+            }
+            else {
                 QVector<QPointF> points = m_points;
                 for (int i = last; i >= first; i--)
-                    points.remove(i - mapFirst);
-                setLayout(points);
-                update();
+                points.remove(i - mapFirst);
+                setGeometryPoints(points);
+                updateGeometry();
             }
             if (mapCount != -1) {
-                int itemsAvailable;     // check how many are available to be added
+                int itemsAvailable; // check how many are available to be added
                 if (m_series->modelMapper()->orientation() == Qt::Vertical)
-                    itemsAvailable = m_series->model()->rowCount() - mapFirst - m_points.size();
+                itemsAvailable = m_series->model()->rowCount() - mapFirst - m_points.size();
                 else
-                    itemsAvailable = m_series->model()->columnCount() - mapFirst - m_points.size();
-                int toBeAdded = qMin(itemsAvailable, mapCount - m_points.size());     // add not more items than there is space left to be filled.
+                itemsAvailable = m_series->model()->columnCount() - mapFirst - m_points.size();
+                int toBeAdded = qMin(itemsAvailable, mapCount - m_points.size());// add not more items than there is space left to be filled.
                 int currentSize = m_points.size();
                 if (toBeAdded > 0)
-                    for (int i = m_points.size(); i < currentSize + toBeAdded; i++) {
-                        handlePointAdded(i);
-                    }
+                for (int i = m_points.size(); i < currentSize + toBeAdded; i++) {
+                    handlePointAdded(i);
+                }
             }
         }
     }
@@ -221,18 +251,23 @@ void XYChartItem::handlePointReplaced(int index)
     QPointF point = calculateGeometryPoint(index);
     QVector<QPointF> points = m_points;
     points.replace(index,point);
-    updateLayout(m_points,points,index);
-    update();
+
+    if(m_animation) {
+        m_animation->setAnimationType(XYAnimation::MoveDownAnimation);
+    }
+
+    updateChart(m_points,points,index);
 }
 
 void XYChartItem::handleReinitialized()
 {
     QVector<QPointF> points = calculateGeometryPoints();
-    if (points.isEmpty())
-        setLayout(points);
-    else
-        updateLayout(m_points,points);
-    update();
+
+    if(m_animation) {
+        m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
+    }
+
+    updateChart(m_points,points);
 }
 
 void XYChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
@@ -243,8 +278,11 @@ void XYChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal 
     m_maxY=maxY;
     if (isEmpty()) return;
     QVector<QPointF> points = calculateGeometryPoints();
-    updateLayout(m_points,points);
-    update();
+
+    if(m_animation) {
+        m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
+    }
+    updateChart(m_points,points);
 }
 
 void XYChartItem::handleGeometryChanged(const QRectF &rect)
@@ -256,11 +294,12 @@ void XYChartItem::handleGeometryChanged(const QRectF &rect)
 
     if (isEmpty()) return;
     QVector<QPointF> points = calculateGeometryPoints();
-    updateLayout(m_points,points);
-    update();
+    if(m_animation) {
+          m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
+      }
+    updateChart(m_points,points);
 }
 
-
 bool XYChartItem::isEmpty()
 {
     return !m_clipRect.isValid() || qFuzzyIsNull(m_maxX - m_minX) || qFuzzyIsNull(m_maxY - m_minY) || m_series->points().isEmpty();
diff --git a/src/xychart/xychartitem_p.h b/src/xychart/xychartitem_p.h
index 1e9bbc6..42b5111 100644
--- a/src/xychart/xychartitem_p.h
+++ b/src/xychart/xychartitem_p.h
@@ -23,6 +23,7 @@
 
 #include "qchartglobal.h"
 #include "chartitem_p.h"
+#include "xyanimation_p.h"
 #include <QPen>
 
 QTCOMMERCIALCHART_BEGIN_NAMESPACE
@@ -37,9 +38,15 @@ public:
      explicit XYChartItem(QXYSeries *series, ChartPresenter *presenter);
     ~XYChartItem(){};
 
-    QVector<QPointF> points() const {return m_points;}
-    QRectF clipRect() const { return m_clipRect;}
+    void setGeometryPoints(QVector<QPointF>& points);
+    QVector<QPointF> geometryPoints() const { return m_points; }
 
+    void setClipRect(const QRectF &rect);
+    QRectF clipRect() const { return m_clipRect; }
+
+    void setAnimation(XYAnimation* animation);
+    ChartAnimation* animation() const { return m_animation; }
+    virtual void updateGeometry();
 
 public Q_SLOTS:
     void handlePointAdded(int index);
@@ -55,10 +62,7 @@ Q_SIGNALS:
     void clicked(const QPointF& point);
 
 protected:
-
-    virtual void setLayout(QVector<QPointF> &points);
-    virtual void updateLayout(QVector<QPointF> &oldPoints,QVector<QPointF> &newPoints,int index = 0);
-
+    virtual void updateChart(QVector<QPointF> &oldPoints,QVector<QPointF> &newPoints,int index = 0);
     QPointF calculateGeometryPoint(const QPointF &point) const;
     QPointF calculateGeometryPoint(int index) const;
     QPointF calculateDomainPoint(const QPointF &point) const;
@@ -77,8 +81,8 @@ private:
     QSizeF m_size;
     QRectF m_clipRect;
     QVector<QPointF> m_points;
+    XYAnimation* m_animation;
 
-    friend class XYAnimation;
     friend class AreaChartItem;
 
 };