HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1241:51695bb27b0e

Refactors axis animation, line animations

Michal Klocek -

r1241:51695bb27b0e

parent child

Context file:

r1241:51695bb27b0e

Expand all files

src/axis/chartaxisx.cpp created 644 +112 0

@@ -0,0 +1,112
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "chartaxisx_p.h"
	22	#include "qaxis.h"
	23	#include "qaxis_p.h"
	24	#include "qaxiscategories_p.h"
	25	#include "chartpresenter_p.h"
	26	#include "chartanimator_p.h"
	27
	28	static int label_padding = 5;
	29
	30	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	31
	32	ChartAxisX::ChartAxisX(QAxis axis,ChartPresenter presenter) : ChartAxis(axis,presenter)
	33	{
	34	}
	35
	36	ChartAxisX::~ChartAxisX()
	37	{
	38	}
	39
	40	QVector<qreal> ChartAxisX::calculateLayout() const
	41	{
	42	Q_ASSERT(m_ticksCount>=2);
	43
	44	QVector<qreal> points;
	45	points.resize(m_ticksCount);
	46
	47	const qreal deltaX = m_rect.width()/(m_ticksCount-1);
	48	for (int i = 0; i < m_ticksCount; ++i) {
	49	int x = i * deltaX + m_rect.left();
	50	points[i] = x;
	51	}
	52	return points;
	53	}
	54
	55	void ChartAxisX::updateGeometry()
	56	{
	57	const QVector<qreal>& layout = ChartAxis::layout();
	58
	59	QStringList ticksList;
	60
	61	bool categories = createLabels(ticksList,m_min,m_max,layout.size());
	62
	63	QList<QGraphicsItem *> lines = m_grid->childItems();
	64	QList<QGraphicsItem *> labels = m_labels->childItems();
	65	QList<QGraphicsItem *> shades = m_shades->childItems();
	66	QList<QGraphicsItem *> axis = m_axis->childItems();
	67
	68	Q_ASSERT(labels.size() == ticksList.size());
	69	Q_ASSERT(layout.size() == ticksList.size());
	70
	71	qreal minWidth = 0;
	72	qreal minHeight = 0;
	73
	74	QGraphicsLineItem lineItem = static_cast<QGraphicsLineItem>(axis.at(0));
	75	lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
	76
	77	for (int i = 0; i < layout.size(); ++i) {
	78	QGraphicsLineItem lineItem = static_cast<QGraphicsLineItem>(lines.at(i));
	79	lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
	80	QGraphicsSimpleTextItem labelItem = static_cast<QGraphicsSimpleTextItem>(labels.at(i));
	81	if (!categories \|\| i<1) {
	82	labelItem->setText(ticksList.at(i));
	83	const QRectF& rect = labelItem->boundingRect();
	84	minWidth+=rect.width();
	85	minHeight=qMax(rect.height(),minHeight);
	86	QPointF center = rect.center();
	87	labelItem->setTransformOriginPoint(center.x(), center.y());
	88	labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
	89	}
	90	else {
	91	labelItem->setText(ticksList.at(i));
	92	const QRectF& rect = labelItem->boundingRect();
	93	minWidth+=rect.width();
	94	minHeight=qMax(rect.height()+label_padding,minHeight);
	95	QPointF center = rect.center();
	96	labelItem->setTransformOriginPoint(center.x(), center.y());
	97	labelItem->setPos(layout[i] - (layout[i] - layout[i-1])/2 - center.x(), m_rect.bottom() + label_padding);
	98	}
	99
	100	if ((i+1)%2 && i>1) {
	101	QGraphicsRectItem rectItem = static_cast<QGraphicsRectItem>(shades.at(i/2-1));
	102	rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
	103	}
	104	lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
	105	lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
	106	}
	107
	108	presenter()->setMinimumMarginWidth(this,minWidth);
	109	presenter()->setMinimumMarginHeight(this,minHeight);
	110	}
	111
	112	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxisx_p.h created 644 +46 0

@@ -0,0 +1,46
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#ifndef CHARTAXISX_H
	22	#define CHARTAXISX_H
	23
	24	#include "chartaxis_p.h"
	25
	26	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	27
	28	class QAxis;
	29	class ChartPresenter;
	30
	31	class ChartAxisX : public ChartAxis
	32	{
	33	public:
	34	ChartAxisX(QAxis axis, ChartPresenter presenter);
	35	~ChartAxisX();
	36
	37	AxisType axisType() const { return X_AXIS;}
	38
	39	protected:
	40	QVector<qreal> calculateLayout() const;
	41	void updateGeometry();
	42	};
	43
	44	QTCOMMERCIALCHART_END_NAMESPACE
	45
	46	#endif /* AXISITEM_H_ */

src/axis/chartaxisy.cpp created 644 +116 0

@@ -0,0 +1,116
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "chartaxisy_p.h"
	22	#include "qaxis.h"
	23	#include "qaxis_p.h"
	24	#include "qaxiscategories_p.h"
	25	#include "chartpresenter_p.h"
	26	#include "chartanimator_p.h"
	27
	28
	29	static int label_padding = 5;
	30
	31	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	32
	33	ChartAxisY::ChartAxisY(QAxis axis,ChartPresenter presenter) : ChartAxis(axis,presenter)
	34	{
	35	}
	36
	37	ChartAxisY::~ChartAxisY()
	38	{
	39	}
	40
	41	QVector<qreal> ChartAxisY::calculateLayout() const
	42	{
	43	Q_ASSERT(m_ticksCount>=2);
	44
	45	QVector<qreal> points;
	46	points.resize(m_ticksCount);
	47
	48	const qreal deltaY = m_rect.height()/(m_ticksCount-1);
	49	for (int i = 0; i < m_ticksCount; ++i) {
	50	int y = i * -deltaY + m_rect.bottom();
	51	points[i] = y;
	52	}
	53
	54	return points;
	55	}
	56
	57	void ChartAxisY::updateGeometry()
	58	{
	59	const QVector<qreal> &layout = ChartAxis::layout();
	60
	61	QStringList ticksList;
	62
	63	bool categories = createLabels(ticksList,m_min,m_max,layout.size());
	64
	65	QList<QGraphicsItem *> lines = m_grid->childItems();
	66	QList<QGraphicsItem *> labels = m_labels->childItems();
	67	QList<QGraphicsItem *> shades = m_shades->childItems();
	68	QList<QGraphicsItem *> axis = m_axis->childItems();
	69
	70	Q_ASSERT(labels.size() == ticksList.size());
	71	Q_ASSERT(layout.size() == ticksList.size());
	72
	73	qreal minWidth = 0;
	74	qreal minHeight = 0;
	75
	76	QGraphicsLineItem lineItem = static_cast<QGraphicsLineItem>(axis.at(0));
	77	lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
	78
	79	for (int i = 0; i < layout.size(); ++i) {
	80	QGraphicsLineItem lineItem = static_cast<QGraphicsLineItem>(lines.at(i));
	81	lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
	82	QGraphicsSimpleTextItem labelItem = static_cast<QGraphicsSimpleTextItem>(labels.at(i));
	83
	84	if (!categories \|\| i<1) {
	85	labelItem->setText(ticksList.at(i));
	86	const QRectF& rect = labelItem->boundingRect();
	87	minWidth=qMax(rect.width()+label_padding,minWidth);
	88	minHeight+=rect.height();
	89	QPointF center = rect.center();
	90	labelItem->setTransformOriginPoint(center.x(), center.y());
	91	labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
	92	}
	93	else {
	94	labelItem->setText(ticksList.at(i));
	95	const QRectF& rect = labelItem->boundingRect();
	96	minWidth=qMax(rect.width(),minWidth);
	97	minHeight+=rect.height();
	98	QPointF center = rect.center();
	99	labelItem->setTransformOriginPoint(center.x(), center.y());
	100	labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i] - (layout[i] - layout[i-1])/2 -center.y());
	101	}
	102
	103	if ((i+1)%2 && i>1) {
	104	QGraphicsRectItem rectItem = static_cast<QGraphicsRectItem>(shades.at(i/2-1));
	105	rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
	106	}
	107	lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
	108	lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
	109	}
	110
	111	presenter()->setMinimumMarginWidth(this,minWidth);
	112	presenter()->setMinimumMarginHeight(this,minHeight);
	113
	114	}
	115
	116	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxisy_p.h created 644 +46 0

@@ -0,0 +1,46
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#ifndef CHARTAXISY_H
	22	#define CHARTAXISY_H
	23
	24	#include "chartaxis_p.h"
	25
	26	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	27
	28	class QAxis;
	29	class ChartPresenter;
	30
	31	class ChartAxisY : public ChartAxis
	32	{
	33	public:
	34	ChartAxisY(QAxis axis, ChartPresenter presenter);
	35	~ChartAxisY();
	36
	37	AxisType axisType() const { return Y_AXIS;}
	38
	39	protected:
	40	QVector<qreal> calculateLayout() const;
	41	void updateGeometry();
	42	};
	43
	44	QTCOMMERCIALCHART_END_NAMESPACE
	45
	46	#endif /* AXISITEM_H_ */

src/animations/axisanimation.cpp +74 -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 "axisanimation_p.h"
+            #include "chartaxis_p.h"
             #include <QTimer>
+            #include <QDebug>
             Q_DECLARE_METATYPE(QVector<qreal>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AxisAnimation::AxisAnimation(ChartAxis *axis): ChartAnimation(axis),
-                m_axis(axis)
+                m_axis(axis),
+                m_type(DefaultAnimation)
             {
+                setDuration(ChartAnimationDuration);
+                setEasingCurve(QEasingCurve::OutQuart);
             }
             AxisAnimation::~AxisAnimation()
             {
             }
+            void AxisAnimation::setAnimationType(Animation type)
+            {
+                if (state() != QAbstractAnimation::Stopped) stop();
+                m_type=type;
+            }
+            void AxisAnimation::setAnimationPoint(const QPointF& point)
+            {
+                if (state() != QAbstractAnimation::Stopped) stop();
+                m_point=point;
+            }
+            void AxisAnimation::setValues(QVector<qreal> &oldLayout, QVector<qreal> &newLayout)
+            {
+                  if (state() != QAbstractAnimation::Stopped) stop();
+                  if (newLayout.count() == 0)
+                      return;
+                  switch (m_type) {
+                  case ZoomOutAnimation: {
+                      QRectF rect = m_axis->geometry();
+                      oldLayout.resize(newLayout.count());
+                      for(int i = 0, j = oldLayout.count() - 1; i < (oldLayout.count() + 1) / 2; ++i, --j) {
+                          oldLayout[i] = m_axis->axisType() == ChartAxis::X_AXIS ? rect.left() : rect.bottom();
+                          oldLayout[j] = m_axis->axisType() == ChartAxis::X_AXIS ? rect.right() : rect.top();
+                      }
+                  }
+                      break;
+                  case ZoomInAnimation: {
+                      int index = qMin(oldLayout.count() * (m_axis->axisType() == ChartAxis::X_AXIS ? m_point.x() : (1 - m_point.y())), newLayout.count() - 1.0);
+                      oldLayout.resize(newLayout.count());
+                      for(int i = 0; i < oldLayout.count(); i++)
+                          oldLayout[i]= oldLayout[index];
+                  }
+                      break;
+                  case MoveForwardAnimation: {
+                      oldLayout.resize(newLayout.count());
+                      for(int i = 0, j = i + 1; i < oldLayout.count() - 1; ++i, ++j)
+                          oldLayout[i]= oldLayout[j];
+                  }
+                      break;
+                  case MoveBackwordAnimation: {
+                      oldLayout.resize(newLayout.count());
+                      for(int i = oldLayout.count() - 1, j = i - 1; i > 0; --i, --j)
+                          oldLayout[i]= oldLayout[j];
+                  }
+                      break;
+                  default: {
+                      oldLayout.resize(newLayout.count());
+                      QRectF rect = m_axis->geometry();
+                      for(int i = 0, j = oldLayout.count() - 1; i < oldLayout.count(); ++i, --j)
+                          oldLayout[i] = m_axis->axisType() == ChartAxis::X_AXIS ? rect.left() : rect.top();
+                  }
+                      break;
+                  }
+                  QVariantAnimation::KeyValues value;
+                  setKeyValues(value); //workaround for wrong interpolation call
+                  setKeyValueAt(0.0, qVariantFromValue(oldLayout));
+                  setKeyValueAt(1.0, qVariantFromValue(newLayout));
+            }
             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);
+                    m_axis->updateGeometry();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/axisanimation_p.h +9 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef AXISANIMATION_H
             #define AXISANIMATION_H
-            #include "chartaxis_p.h"
             #include "chartanimation_p.h"
+            #include <QPointF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            class ChartAxis;
             class AxisAnimation: public ChartAnimation
             {
             public:
+                enum Animation { DefaultAnimation, ZoomOutAnimation, ZoomInAnimation, MoveForwardAnimation, MoveBackwordAnimation};
                 AxisAnimation(ChartAxis *axis);
                 ~AxisAnimation();
+                void setAnimationType(Animation type);
+                void setAnimationPoint(const QPointF& point);
+                void setValues(QVector<qreal> &oldLayout, QVector<qreal> &newLayout);
             protected:
                 QVariant interpolated(const QVariant &from, const QVariant &to, qreal progress ) const;
                 void updateCurrentValue(const QVariant &value );
             private:
                 ChartAxis *m_axis;
+                Animation m_type;
+                QPointF m_point;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/animations/chartanimation_p.h +1 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$
             **
             ****************************************************************************/
             #ifndef CHARTANIMATION_H
             #define CHARTANIMATION_H
             #include "qchartglobal.h"
             #include <QVariantAnimation>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             const static int ChartAnimationDuration = 1000;
             class ChartAnimation: public QVariantAnimation
             {
+                Q_OBJECT
             public:
                 ChartAnimation(QObject *parent = 0):QVariantAnimation(parent){};
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/animations/chartanimator.cpp +2 -100

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

src/animations/chartanimator_p.h 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$
             **
             ****************************************************************************/
             #ifndef CHARTANIMATOR_P_H
             #define CHARTANIMATOR_P_H
             #include "qchartglobal.h"
             #include "chartanimation_p.h"
             #include "piechartitem_p.h"
             #include "barchartitem_p.h"
             #include <QPointF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class ChartAxis;
             class AreaChartItem;
             class SplineChartItem;
             class ScatterChartItem;
             class LineChartItem;
             class XYChartItem;
             class XYAnimation;
             class ChartAnimator : public QObject
             {
                 Q_OBJECT
             public:
-                enum State{ShowState, ScrollUpState, ScrollDownState, ScrollLeftState, ScrollRightState, ZoomInState, ZoomOutState};
                 ChartAnimator(QObject *parent = 0);
                 virtual ~ChartAnimator();
-                void addAnimation(ChartAxis *item);
                 void addAnimation(PieChartItem *item);
                 void addAnimation(BarChartItem *item);
                 void removeAnimation(Chart *item);
-                void animationStarted();
-                void updateLayout(ChartAxis *item, QVector<qreal> &layout);
                 void addAnimation(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData, bool isEmpty);
                 void removeAnimation(PieChartItem *item, PieSliceItem *sliceItem);
                 void updateAnimation(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData);
                 void updateLayout(BarChartItem *item, const QVector<QRectF> &oldLayout, const QVector<QRectF> &newLayout);
-                void setState(State state,const QPointF &point = QPointF());
-                void startAnimation(XYAnimation* animation);
             private:
                  QMap<Chart *, ChartAnimation *> m_animations;
-                 State m_state;
-                 QPointF m_point;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/animations/splineanimation.cpp +5 -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 "splineanimation_p.h"
             #include "splinechartitem_p.h"
             #include <QDebug>
             Q_DECLARE_METATYPE(QVector<QPointF>)
             Q_DECLARE_METATYPE(SplineVector)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             SplineAnimation::SplineAnimation(SplineChartItem* item):XYAnimation(item),
                 m_item(item),
                 m_dirty(true)
             {
             }
             SplineAnimation::~SplineAnimation()
             {
             }
             void SplineAnimation::setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldControlPoints, QVector<QPointF> &newControlPoints, int index)
             {
                 int x = oldPoints.count();
                 int y = newPoints.count();
                 Q_ASSERT(newPoints.count() * 2 - 2 == newControlPoints.count());
                 if (x != y && abs(x - y) != 1) {
                     m_oldSpline.first = newPoints;
                     m_oldSpline.second = newControlPoints;
                     oldPoints.resize(newPoints.size());
                     oldControlPoints.resize(newControlPoints.size());
                     SplineVector oldPair;
                     oldPair.first = oldPoints;
                     oldPair.second = oldControlPoints;
                     SplineVector newPair;
                     newPair.first = newPoints;
                     newPair.second = newControlPoints;
                     setKeyValueAt(0.0, qVariantFromValue(oldPair));
                     setKeyValueAt(1.0, qVariantFromValue(newPair));
                     m_dirty = false;
                 }
                 else {
                     if(m_dirty) {
                         m_oldSpline.first = oldPoints;
                         m_oldSpline.second = oldControlPoints;
                         m_dirty = false;
                     }
                     oldPoints = newPoints;
                     oldControlPoints = newControlPoints;
                     if (y < x) {
                         m_oldSpline.first.remove(index); //remove
                         m_oldSpline.second.remove(index * 2);
                         m_oldSpline.second.remove(index * 2);
                     }
                     if (y > x) {
                         m_oldSpline.first.insert(index, x > 0 ? m_oldSpline.first[index-1] : newPoints[index]); //add
                         m_oldSpline.second.insert((index - 1) * 2, x > 1 ? m_oldSpline.second[(index-2)*2] : newControlPoints[(index - 1) * 2]); //add
                         m_oldSpline.second.insert((index - 1) * 2 + 1, x > 1 ? m_oldSpline.second[(index - 2) * 2 + 1] : newControlPoints[(index - 1) * 2 + 1]); //add
                     }
                     SplineVector newPair;
                     newPair.first=newPoints;
                     newPair.second=newControlPoints;
                     setKeyValueAt(0.0, qVariantFromValue(m_oldSpline));
                     setKeyValueAt(1.0, qVariantFromValue(newPair));
                 }
             }
             QVariant SplineAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress ) const
             {
                 SplineVector startPair  =  qVariantValue< SplineVector >(start);
                 SplineVector endPair =  qVariantValue< SplineVector >(end);
                 SplineVector result;
                 switch (animationType()) {
-                case MoveDownAnimation: {
+                case RemovePointAnimation:
+                case AddPointAnimation:
+                case ReplacePointAnimation:
+                {
                     if (startPair.first.count() != endPair.first.count())
                         break;
                     Q_ASSERT(startPair.first.count() * 2 - 2 == startPair.second.count());
                     Q_ASSERT(endPair.first.count() * 2 - 2 == endPair.second.count());
                     for(int i = 0; i < endPair.first.count(); i++) {
                         qreal x = startPair.first[i].x() + ((endPair.first[i].x() - startPair.first[i].x()) * progress);
                         qreal y = startPair.first[i].y() + ((endPair.first[i].y() - startPair.first[i].y()) * progress);
                         result.first << QPointF(x,y);
                         if (i + 1 >= endPair.first.count())
                             continue;
                         x = startPair.second[i * 2].x() + ((endPair.second[i * 2].x() - startPair.second[i * 2].x()) * progress);
                         y = startPair.second[i * 2].y() + ((endPair.second[i * 2].y() - startPair.second[i * 2].y()) * progress);
                         result.second << QPoint(x,y);
                         x = startPair.second[i * 2 + 1].x() + ((endPair.second[i * 2 + 1].x() - startPair.second[i * 2 + 1].x()) * progress);
                         y = startPair.second[i * 2 + 1].y() + ((endPair.second[i * 2 + 1].y() - startPair.second[i * 2 + 1].y()) * progress);
                         result.second << QPoint(x,y);
                     }
                 }
                     break;
-                case LineDrawAnimation:{
+                case NewAnimation:{
                     Q_ASSERT(endPair.first.count() * 2 - 2 == endPair.second.count());
                     int count = endPair.first.count()* qBound(qreal(0), progress, qreal(1));
                     for(int i = 0; i < count; i++) {
                         result.first << endPair.first[i];
                         if(i + 1 == count)
                             break;
                         result.second << endPair.second[2 * i];
                         result.second << endPair.second[2 * i + 1];
                     }
                 }
                     break;
                 default:
                     qWarning() << "Unknown type of animation";
                     break;
                 }
                 return qVariantFromValue(result);
             }
             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->setGeometryPoints(pair.first);
                     m_item->setControlGeometryPoints(pair.second);
                     m_item->updateGeometry();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/xyanimation.cpp +53 -27

             /****************************************************************************
             **
             ** 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 "xyanimation_p.h"
             #include "xychart_p.h"
             #include <QDebug>
             Q_DECLARE_METATYPE(QVector<QPointF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             XYAnimation::XYAnimation(XYChart *item):ChartAnimation(item),
                 m_item(item),
                 m_dirty(false),
-                m_type(MoveDownAnimation)
+                m_type(NewAnimation)
             {
+                setDuration(ChartAnimationDuration);
+                setEasingCurve(QEasingCurve::OutQuart);
             }
             XYAnimation::~XYAnimation()
             {
             }
             void XYAnimation::setAnimationType(Animation type)
             {
-                if (state() != QAbstractAnimation::Stopped) stop();
+            	if (state() != QAbstractAnimation::Stopped) stop();
                 m_type=type;
             }
-            void XYAnimation::setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
+            void XYAnimation::setValues(const QVector<QPointF> &oldPoints, const QVector<QPointF> &newPoints, int index)
             {
-                if (state() != QAbstractAnimation::Stopped) stop();
+            	if (state() != QAbstractAnimation::Stopped) stop();
-                int x = oldPoints.count();
+                if (m_item->isDirty()) {
-                int y = newPoints.count();
+                    m_oldPoints = oldPoints;
+                    m_newPoints = newPoints;
-                if (x != y && abs(x - y) != 1) {
+                    m_dirty=false;
-                    m_oldPoints = newPoints;
-                    oldPoints.resize(newPoints.size());
-                    setKeyValueAt(0.0, qVariantFromValue(oldPoints));
-                    setKeyValueAt(1.0, qVariantFromValue(newPoints));
-                    m_dirty = false;
                 }
                 else {
-                    if (m_dirty) {
+                    if(m_dirty) {
+                        m_newPoints = newPoints;
                         m_oldPoints = oldPoints;
-                        m_dirty = false;
+                        m_dirty=false;
+                    }
+                }
+                int x = m_oldPoints.count();
+                int y = m_newPoints.count();
+                if (abs(x - y) == 1) {
+                    if (y < x){
+                        if(!newPoints.isEmpty()) m_newPoints.insert(index,newPoints[index]);
+                        m_index=index;if(newPoints.isEmpty())
+                        m_dirty=true;
+                    }
+                    if (y > x){
+                        m_oldPoints.insert(index, x > 0 ? m_oldPoints[index-1] : newPoints[index]);//add
                     }
-                    oldPoints = newPoints;
+                }else{
-                    if (y < x)
+                    m_newPoints=newPoints;
-                        m_oldPoints.remove(index); //remove
+                    m_dirty=false;
-                    if (y > x)
+                    m_oldPoints.resize(m_newPoints.size());
-                        m_oldPoints.insert(index, x > 0 ? m_oldPoints[index-1] : newPoints[index]); //add
-                    setKeyValueAt(0.0, qVariantFromValue(m_oldPoints));
-                    setKeyValueAt(1.0, qVariantFromValue(newPoints));
-                    Q_ASSERT(m_oldPoints.count() == newPoints.count());
                 }
+                setKeyValueAt(0.0, qVariantFromValue(m_oldPoints));
+                setKeyValueAt(1.0, qVariantFromValue(m_newPoints));
             }
             QVariant XYAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress ) const
             {
                 QVector<QPointF> startVector = qVariantValue<QVector<QPointF> >(start);
                 QVector<QPointF> endVector = qVariantValue<QVector<QPointF> >(end);
                 QVector<QPointF> result;
                 switch (m_type) {
-                case MoveDownAnimation: {
+                case ReplacePointAnimation:
+                case AddPointAnimation:
+                case RemovePointAnimation:
+                {
                     if (startVector.count() != endVector.count())
                         break;
                     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: {
+                case NewAnimation: {
                     for(int i = 0; i < endVector.count() * qBound(qreal(0), progress, qreal(1)); i++)
                         result << endVector[i];
                 }
                     break;
                 default:
                     qWarning() << "Unknown type of animation";
                     break;
                 }
                 return qVariantFromValue(result);
             }
             void XYAnimation::updateCurrentValue (const QVariant &value)
             {
                 if(state()!=QAbstractAnimation::Stopped){ //workaround
-                    m_dirty = true;
                     QVector<QPointF> vector = qVariantValue<QVector<QPointF> >(value);
                     m_item->setGeometryPoints(vector);
                     m_item->updateGeometry();
+                    m_item->setDirty(true);
                 }
             }
+            void XYAnimation::updateState( QAbstractAnimation::State newState, QAbstractAnimation::State oldState )
+            {
+            	if(oldState == QAbstractAnimation::Running && newState == QAbstractAnimation::Stopped)
+            	{
+            		if(m_item->isDirty() && m_type==RemovePointAnimation){
+            		    if(!m_newPoints.isEmpty()) m_newPoints.remove(m_index);
+            			m_item->setGeometryPoints(m_newPoints);
+            		}
+            	}
+            }
+            #include "moc_chartanimation_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/xyanimation_p.h +5 -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$
             **
             ****************************************************************************/
             #ifndef XYANIMATION_P_H
             #define XYANIMATION_P_H
             #include "chartanimation_p.h"
             #include <QPointF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class XYChart;
             class XYAnimation : public ChartAnimation
             {
             public:
-                enum Animation { LineDrawAnimation, MoveDownAnimation, MoveUpAnimation };
+                enum Animation { AddPointAnimation, RemovePointAnimation, ReplacePointAnimation, NewAnimation };
                 XYAnimation(XYChart *item);
                 ~XYAnimation();
-                void setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index);
+                void setValues(const QVector<QPointF> &oldPoints, const 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;
                 void updateCurrentValue (const QVariant &value );
+                void updateState( QAbstractAnimation::State newState, QAbstractAnimation::State oldState );
             private:
                 XYChart *m_item;
                 QVector<QPointF> m_oldPoints;
+                QVector<QPointF> m_newPoints;
+                int m_index;
                 bool m_dirty;
                 Animation m_type;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/areachart/areachartitem.cpp +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$
             **
             ****************************************************************************/
             #include "areachartitem_p.h"
             #include "qareaseries.h"
             #include "qareaseries_p.h"
             #include "qlineseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             AreaChartItem::AreaChartItem(QAreaSeries *areaSeries, ChartPresenter *presenter)
                 : ChartItem(presenter),
                 m_series(areaSeries),
                 m_upper(0),
                 m_lower(0),
                 m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
-                m_upper = new AreaBoundItem(this,m_series->upperSeries());
+                m_upper = new AreaBoundItem(this,m_series->upperSeries(),presenter);
                 if (m_series->lowerSeries())
-                    m_lower = new AreaBoundItem(this,m_series->lowerSeries());
+                    m_lower = new AreaBoundItem(this,m_series->lowerSeries(),presenter);
                 QObject::connect(m_series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
                 QObject::connect(this,SIGNAL(clicked(QPointF)),areaSeries,SIGNAL(clicked(QPointF)));
                 handleUpdated();
             }
             AreaChartItem::~AreaChartItem()
             {
                 delete m_upper;
                 delete m_lower;
             }
             QRectF AreaChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath AreaChartItem::shape() const
             {
                 return m_path;
             }
             void AreaChartItem::updatePath()
             {
                 QPainterPath path;
                 path = m_upper->shape();
                 if (m_lower) {
                     path.connectPath(m_lower->shape().toReversed());
                 } else {
                     QPointF first = path.pointAtPercent(0);
                     QPointF last =  path.pointAtPercent(1);
                     path.lineTo(last.x(),m_clipRect.bottom());
                     path.lineTo(first.x(),m_clipRect.bottom());
                 }
                 path.closeSubpath();
                 prepareGeometryChange();
                 m_path = path;
                 m_rect = path.boundingRect();
                 update();
             }
             void AreaChartItem::handleUpdated()
             {
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_brush = m_series->brush();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2 * m_pointPen.width());
                 update();
             }
             void AreaChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_upper->handleDomainChanged(minX,maxX,minY,maxY);
                 if (m_lower)
                     m_lower->handleDomainChanged(minX,maxX,minY,maxY);
             }
             void AreaChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 m_clipRect=rect.translated(-rect.topLeft());
                 setPos(rect.topLeft());
                 m_upper->handleGeometryChanged(rect);
                 if (m_lower)
                     m_lower->handleGeometryChanged(rect);
             }
             void AreaChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(m_brush);
                 painter->setClipRect(m_clipRect);
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                        painter->setPen(m_pointPen);
                        painter->drawPoints(m_upper->geometryPoints());
                        if (m_lower)
                            painter->drawPoints(m_lower->geometryPoints());
                 }
                 painter->restore();
             }
             void AreaChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(m_upper->calculateDomainPoint(event->pos()));
             }
             #include "moc_areachartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/areachartitem_p.h +3 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef AREACHARTITEM_H
             #define AREACHARTITEM_H
             #include "qchartglobal.h"
             #include "linechartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAreaSeries;
             class AreaChartItem;
             class AreaChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
                 AreaChartItem(QAreaSeries *areaSeries, ChartPresenter *presenter);
                 ~AreaChartItem();
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
                 LineChartItem* upperLineItem() const { return m_upper; }
                 LineChartItem* lowerLineItem() const { return m_lower; }
                 void updatePath();
             protected:
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             Q_SIGNALS:
                 void clicked(const QPointF &point);
             public Q_SLOTS:
                 void handleUpdated();
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF &size);
             private:
                 QAreaSeries* m_series;
                 LineChartItem* m_upper;
                 LineChartItem* m_lower;
                 QPainterPath m_path;
                 QRectF m_rect;
                 QRectF m_clipRect;
                 QPen m_linePen;
                 QPen m_pointPen;
                 QBrush m_brush;
                 bool m_pointsVisible;
             };
             class AreaBoundItem : public LineChartItem
             {
             public:
-                AreaBoundItem(AreaChartItem *item,QLineSeries *lineSeries) : LineChartItem(lineSeries, 0), m_item(item) {}
+                AreaBoundItem(AreaChartItem *item,QLineSeries *lineSeries,ChartPresenter* presenter) : LineChartItem(lineSeries, 0), m_item(item) {
+                    setPresenter(presenter);
+                }
                 ~AreaBoundItem() {}
                 void updateGeometry() {
                     LineChartItem::updateGeometry();
                     m_item->updatePath();
                 }
             private:
                 AreaChartItem* m_item;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/axis/axis.pri +4 0

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/chartaxis.cpp \
+                $$PWD/chartaxisx.cpp \
+                $$PWD/chartaxisy.cpp \
                 $$PWD/qaxis.cpp \
                 $$PWD/qaxiscategories.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartaxis_p.h \
+                $$PWD/chartaxisx_p.h \
+                $$PWD/chartaxisy_p.h \
                 $$PWD/qaxis_p.h \
                 $$PWD/qaxiscategories_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qaxis.h \
                 $$PWD/qaxiscategories.h

src/axis/chartaxis.cpp +55 -160

             /****************************************************************************
             **
             ** 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 "qaxis.h"
             #include "qaxis_p.h"
             #include "qaxiscategories_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QDebug>
             #include <cmath>
-            static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartAxis::ChartAxis(QAxis *axis,ChartPresenter *presenter,AxisType type) : Chart(presenter),
+            ChartAxis::ChartAxis(QAxis *axis,ChartPresenter *presenter) : Chart(presenter),
                 m_chartAxis(axis),
-                m_type(type),
                 m_labelsAngle(0),
                 m_grid(new QGraphicsItemGroup(presenter->rootItem())),
                 m_shades(new QGraphicsItemGroup(presenter->rootItem())),
                 m_labels(new QGraphicsItemGroup(presenter->rootItem())),
                 m_axis(new QGraphicsItemGroup(presenter->rootItem())),
                 m_min(0),
                 m_max(0),
-                m_ticksCount(0)
+                m_ticksCount(0),
+                m_animation(0)
             {
                 //initial initialization
                 m_axis->setZValue(ChartPresenter::AxisZValue);
                 m_axis->setHandlesChildEvents(false);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 QObject::connect(m_chartAxis->d_ptr.data(),SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
                 QObject::connect(m_chartAxis->categories()->d_ptr.data(),SIGNAL(updated()),this,SLOT(handleAxisCategoriesUpdated()));
                 handleAxisUpdated();
             }
             ChartAxis::~ChartAxis()
             {
             }
-            void ChartAxis::createItems(int count)
+            void ChartAxis::setAnimation(AxisAnimation* animation)
             {
+                m_animation=animation;
+            }
+            void ChartAxis::setLayout(QVector<qreal> &layout)
+            {
+                m_layoutVector=layout;
+            }
+            void ChartAxis::createItems(int count)
+            {
                 if (m_axis->children().size() == 0)
-                    m_axis->addToGroup(new AxisItem(this));
+                m_axis->addToGroup(new AxisItem(this));
                 for (int i = 0; i < count; ++i) {
                     m_grid->addToGroup(new QGraphicsLineItem());
                     m_labels->addToGroup(new QGraphicsSimpleTextItem());
                     m_axis->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_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());
                     delete(axis.takeLast());
                 }
             }
             void ChartAxis::updateLayout(QVector<qreal> &layout)
             {
-                if (animator()) {
+                int diff = m_layoutVector.size() - layout.size();
-                    animator()->updateLayout(this,layout);
-                } else {
+                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();
                 }
             }
             bool ChartAxis::createLabels(QStringList &labels,qreal min, qreal max,int ticks) const
             {
-                Q_ASSERT(max>=min);
+                Q_ASSERT(max>min);
                 Q_ASSERT(ticks>1);
                 QAxisCategories* categories = m_chartAxis->categories();
                 bool category = categories->count()>0;
                 if (!category) {
                     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));
+                        Q_UNUSED(value);
                         labels << QString::number(value,'f',n);
                     }
                 } else {
                     QList<qreal> values = categories->values();
                     for (int i=0; i< ticks; i++) {
                         qreal value = (min + (i * (max - min)/ (ticks-1)));
                         int j=0;
                         for (; j<values.count(); j++) {
                             if (values.at(j) > value) break;
                         }
                         if (j!=0) value=values.at(j-1);
                         QString label = categories->label(value);
                         labels << label;
                     }
                 }
                 return category;
             }
             void ChartAxis::setAxisOpacity(qreal opacity)
             {
                 m_axis->setOpacity(opacity);
             }
             qreal ChartAxis::axisOpacity() const
             {
                 return m_axis->opacity();
             }
             void ChartAxis::setGridOpacity(qreal opacity)
             {
                 m_grid->setOpacity(opacity);
             }
             qreal ChartAxis::gridOpacity() const
             {
                 return m_grid->opacity();
             }
             void ChartAxis::setLabelsOpacity(qreal opacity)
             {
                 m_labels->setOpacity(opacity);
             }
             qreal ChartAxis::labelsOpacity() const
             {
                 return m_labels->opacity();
             }
             void ChartAxis::setShadesOpacity(qreal opacity)
             {
                 m_shades->setOpacity(opacity);
             }
             qreal ChartAxis::shadesOpacity() const
             {
                 return m_shades->opacity();
             }
             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);
                 }
             }
             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::setAxisPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_axis->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);
                 }
             }
-            QVector<qreal> ChartAxis::calculateLayout() const
-                Q_ASSERT(m_ticksCount>=2);
-                QVector<qreal> points;
-                points.resize(m_ticksCount);
-                switch (m_type)
-                    case X_AXIS:
-                        const qreal deltaX = m_rect.width()/(m_ticksCount-1);
-                        for (int i = 0; i < m_ticksCount; ++i) {
-                             int x = i * deltaX + m_rect.left();
-                             points[i] = x;
-                    break;
-                    case Y_AXIS:
-                        const qreal deltaY = m_rect.height()/(m_ticksCount-1);
-                        for (int i = 0; i < m_ticksCount; ++i) {
-                             int y = i * -deltaY + m_rect.bottom();
-                             points[i] = y;
-                    break;
-                return points;
-            void ChartAxis::setLayout(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();
-            	QStringList ticksList;
-                bool categories = 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_axis->childItems();
-            	Q_ASSERT(labels.size() == ticksList.size());
-            	Q_ASSERT(layout.size() == ticksList.size());
-            	qreal minWidth = 0;
-            	qreal minHeight = 0;
-            	switch (m_type)
-            		case X_AXIS:
-            			QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
-            			lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
-            			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 (!categories || i<1) {
-            				    labelItem->setText(ticksList.at(i));
-            				    const QRectF& rect = labelItem->boundingRect();
-            				    minWidth+=rect.width();
-            				    minHeight=qMax(rect.height(),minHeight);
-            				    QPointF center = rect.center();
-            				    labelItem->setTransformOriginPoint(center.x(), center.y());
-            				    labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
-                            } else {
-            				    labelItem->setText(ticksList.at(i));
-            			        const QRectF& rect = labelItem->boundingRect();
-            			        minWidth+=rect.width();
-            			        minHeight=qMax(rect.height()+label_padding,minHeight);
-            				    QPointF center = rect.center();
-            				    labelItem->setTransformOriginPoint(center.x(), center.y());
-            				    labelItem->setPos(layout[i] - (layout[i] - layout[i-1])/2 - center.x(), m_rect.bottom() + label_padding);
-                            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);
-            		break;
-            		case Y_AXIS:
-            			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 (!categories || i<1) {
-            				    labelItem->setText(ticksList.at(i));
-            				    const QRectF& rect = labelItem->boundingRect();
-            				    minWidth=qMax(rect.width()+label_padding,minWidth);
-            				    minHeight+=rect.height();
-            				    QPointF center = rect.center();
-            				    labelItem->setTransformOriginPoint(center.x(), center.y());
-            				    labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
-                            } else {
-            				    labelItem->setText(ticksList.at(i));
-            				    const QRectF& rect = labelItem->boundingRect();
-            				    minWidth=qMax(rect.width(),minWidth);
-            				    minHeight+=rect.height();
-            				    QPointF center = rect.center();
-            				    labelItem->setTransformOriginPoint(center.x(), center.y());
-            				    labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i] - (layout[i] - layout[i-1])/2 -center.y());
-                            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]);
-            		break;
-            		default:
-            		    qWarning()<<"Unknown axis type";
-            		break;
-                m_layoutVector=layout;
-                presenter()->setMinimumMarginWidth(this,minWidth);
-                presenter()->setMinimumMarginHeight(this,minHeight);
             bool ChartAxis::isEmpty()
             {
                 return m_rect.isEmpty() || qFuzzyIsNull(m_min - m_max) || m_ticksCount==0;
             }
             //handlers
             void ChartAxis::handleAxisCategoriesUpdated()
             {
                 if (isEmpty()) return;
             	updateLayout(m_layoutVector);
             }
             void ChartAxis::handleAxisUpdated()
             {
                 if (isEmpty()) return;
                 if (m_chartAxis->isAxisVisible()) {
                     setAxisOpacity(100);
                 } else {
                     setAxisOpacity(0);
                 }
                 if (m_chartAxis->isGridLineVisible()) {
                     setGridOpacity(100);
                 } else {
                     setGridOpacity(0);
                 }
                 if (m_chartAxis->labelsVisible()) {
                     setLabelsOpacity(100);
                 } else {
                     setLabelsOpacity(0);
                 }
                 if (m_chartAxis->shadesVisible()) {
                     setShadesOpacity(m_chartAxis->shadesOpacity());
                 } else {
                     setShadesOpacity(0);
                 }
                 setLabelsAngle(m_chartAxis->labelsAngle());
                 setAxisPen(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::handleRangeChanged(qreal min, qreal max,int tickCount)
             {
                 if (qFuzzyIsNull(min - max) || tickCount < 2)
                     return;
                 m_min = min;
                 m_max = max;
                 m_ticksCount= tickCount;
                 if (isEmpty()) return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             void ChartAxis::handleGeometryChanged(const QRectF &rect)
             {
                 if(m_rect != rect)
                 {
                     m_rect = rect;
                     if (isEmpty()) return;
                     QVector<qreal> layout = calculateLayout();
                     updateLayout(layout);
                 }
             }
             void ChartAxis::axisSelected()
             {
                 qDebug()<<"TODO: axis clicked";
             }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxis_p.h +20 -15

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
-            #ifndef AXIS_H
+            #ifndef CHARTAXIS_H
-            #define AXIS_H
+            #define CHARTAXIS_H
             #include "qchartglobal.h"
             #include "chart_p.h"
+            #include "axisanimation_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAxis;
             class ChartPresenter;
             class ChartAxis : public Chart
             {
                 Q_OBJECT
             public:
-                enum AxisType{X_AXIS,Y_AXIS};
+                enum AxisType{ X_AXIS,Y_AXIS };
-                ChartAxis(QAxis *axis, ChartPresenter *presenter, AxisType type = X_AXIS);
+                ChartAxis(QAxis *axis, ChartPresenter *presenter);
                 ~ChartAxis();
-                AxisType axisType() const { return m_type; }
+                virtual AxisType axisType() const = 0;
                 void setAxisOpacity(qreal opacity);
                 qreal axisOpacity() const;
                 void setGridOpacity(qreal opacity);
                 qreal gridOpacity() const;
                 void setLabelsOpacity(qreal opacity);
                 qreal labelsOpacity() const;
                 void setShadesOpacity(qreal opacity);
                 qreal shadesOpacity() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle()const { return m_labelsAngle; }
                 void setShadesBrush(const QBrush &brush);
                 void setShadesPen(const QPen &pen);
                 void setAxisPen(const QPen &pen);
                 void setGridPen(const QPen &pen);
                 void setLabelsPen(const QPen &pen);
                 void setLabelsBrush(const QBrush &brush);
                 void setLabelsFont(const QFont &font);
-                inline QRectF geometry() const { return m_rect; }
+                void setLayout(QVector<qreal> &layout);
-                inline QVector<qreal> layout() { return m_layoutVector; }
+                QVector<qreal> layout() const { return m_layoutVector; }
+                void setAnimation(AxisAnimation* animation);
+                ChartAnimation* animation() const { return m_animation; };
+                QRectF geometry() const { return m_rect; }
+            protected:
+                virtual void updateGeometry() = 0;
+                virtual QVector<qreal> calculateLayout() const = 0;
+                bool createLabels(QStringList &labels,qreal min, qreal max,int ticks) const;
             public Q_SLOTS:
                 void handleAxisUpdated();
                 void handleAxisCategoriesUpdated();
                 void handleRangeChanged(qreal min , qreal max,int tickCount);
                 void handleGeometryChanged(const QRectF &size);
             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);
-                bool createLabels(QStringList &labels,qreal min, qreal max,int ticks) const;
                 void axisSelected();
-            private:
+            protected:
                 QAxis* m_chartAxis;
-                AxisType m_type;
                 QRectF m_rect;
                 int m_labelsAngle;
                 QScopedPointer<QGraphicsItemGroup> m_grid;
                 QScopedPointer<QGraphicsItemGroup> m_shades;
                 QScopedPointer<QGraphicsItemGroup> m_labels;
                 QScopedPointer<QGraphicsItemGroup> m_axis;
                 QVector<qreal> m_layoutVector;
                 qreal m_min;
                 qreal m_max;
                 int m_ticksCount;
+                AxisAnimation *m_animation;
                 friend class AxisAnimation;
                 friend class AxisItem;
             };
             class AxisItem: public QGraphicsLineItem
             {
             public:
                 explicit AxisItem(ChartAxis *axis, QGraphicsItem *parent = 0) : QGraphicsLineItem(parent), m_axis(axis) {}
             protected:
                void mousePressEvent(QGraphicsSceneMouseEvent *event)
                {
                    Q_UNUSED(event)
                    m_axis->axisSelected();
                }
                QRectF boundingRect() const
                {
                   return shape().boundingRect();
                }
                QPainterPath shape() const
                {
                    QPainterPath path = QGraphicsLineItem::shape();
                    QRectF rect = path.boundingRect();
                    path.addRect(rect.adjusted(0,0,m_axis->axisType()!=ChartAxis::X_AXIS?8:0,m_axis->axisType()!=ChartAxis::Y_AXIS?8:0));
                    return path;
                }
             private:
                ChartAxis* m_axis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/chartpresenter.cpp +43 -27

             /****************************************************************************
              **
              ** 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 "qaxis.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 <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_chartRect(QRectF(QPoint(0,0),m_chart->size())),
             m_options(QChart::NoAnimation),
             m_minLeftMargin(0),
             m_minBottomMargin(0),
+            m_state(ShowState),
             m_backgroundItem(0),
             m_titleItem(0),
             m_marginBig(60),
             m_marginSmall(20),
             m_marginTiny(10),
             m_chartMargins(QRect(m_marginBig,m_marginBig,0,0))
             {
             }
             ChartPresenter::~ChartPresenter()
             {
                 delete m_chartTheme;
             }
             void ChartPresenter::setGeometry(const QRectF& rect)
             {
                 m_rect = rect;
                 Q_ASSERT(m_rect.isValid());
                 updateLayout();
             }
             void ChartPresenter::setMinimumMarginWidth(ChartAxis* axis, qreal width)
             {
                 switch(axis->axisType()){
                 case ChartAxis::X_AXIS:
                 {
                     if(width>m_chartRect.width()+ m_chartMargins.left()) {
                         m_minLeftMargin= width - m_chartRect.width();
                         updateLayout();
                     }
                     break;
                 }
                 case ChartAxis::Y_AXIS:
                 {
                     if(m_minLeftMargin!=width){
                         m_minLeftMargin= width;
                         updateLayout();
                     }
                     break;
                 }
                 }
             }
             void ChartPresenter::setMinimumMarginHeight(ChartAxis* axis, qreal height)
             {
                 switch(axis->axisType()){
                 case ChartAxis::X_AXIS:
                 {
                     if(m_minBottomMargin!=height) {
                         m_minBottomMargin= height;
                         updateLayout();
                     }
                     break;
                 }
                 case ChartAxis::Y_AXIS:
                 {
                     if(height>m_chartMargins.bottom()+m_chartRect.height()){
                         m_minBottomMargin= height - m_chartRect.height();
                         updateLayout();
                     }
                     break;
                 }
                 }
             }
             void ChartPresenter::handleAxisAdded(QAxis* axis,Domain* domain)
             {
-                ChartAxis* item = new ChartAxis(axis,this,axis==m_dataset->axisX()?ChartAxis::X_AXIS : ChartAxis::Y_AXIS);
+                ChartAxis* item;
+                if(axis == m_dataset->axisX()){
+                    item = new ChartAxisX(axis,this);
+                }else{
+                    item = new ChartAxisY(axis,this);
+                }
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
-                    m_animator->addAnimation(item);
+                    item->setAnimator(m_animator);
+                    item->setAnimation(new AxisAnimation(item));
                 }
                 if(axis==m_dataset->axisX()){
                     m_chartTheme->decorate(axis,true);
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX(),domain->tickXCount());
                 }
                 else{
                     m_chartTheme->decorate(axis,false);
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY(),domain->tickYCount());
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
                 //initialize
                 if(m_chartRect.isValid()) item->handleGeometryChanged(m_chartRect);
                 m_axisItems.insert(axis, item);
             }
             void ChartPresenter::handleAxisRemoved(QAxis* axis)
             {
                 ChartAxis* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QAbstractSeries* series,Domain* domain)
             {
                 Chart *item = series->d_ptr->createGraphics(this);
                 Q_ASSERT(item);
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
                 QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                 //initialize
                 item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                 if(m_chartRect.isValid()) item->handleGeometryChanged(m_chartRect);
                 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);
                 }
                 delete item;
             }
             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()
             {
                 QList<QAxis *> axisList = m_axisItems.uniqueKeys();
                 QList<QAbstractSeries *> seriesList = m_chartItems.uniqueKeys();
                 foreach(QAxis *axis, axisList) {
                     handleAxisRemoved(axis);
                     handleAxisAdded(axis,m_dataset->domain(axis));
                 }
                 foreach(QAbstractSeries *series, seriesList) {
                     handleSeriesRemoved(series);
                     handleSeriesAdded(series,m_dataset->domain(series));
             //        m_dataset->removeSeries(series);
             //        m_dataset->addSeries(series);
                 }
             }
             void ChartPresenter::zoomIn(qreal factor)
             {
                 QRectF rect = chartGeometry();
                 rect.setWidth(rect.width()/factor);
                 rect.setHeight(rect.height()/factor);
                 rect.moveCenter(chartGeometry().center());
                 zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
                 QRectF r = rect.normalized();
                 r.translate(-m_chartMargins.topLeft());
                 if (!r.isValid())
                     return;
-                if (m_animator) {
+                m_state = ZoomInState;
-                    QPointF point(r.center().x()/chartGeometry().width(),r.center().y()/chartGeometry().height());
+                m_statePoint = QPointF(r.center().x()/chartGeometry().width(),r.center().y()/chartGeometry().height());
-                    m_animator->setState(ChartAnimator::ZoomInState,point);
                 m_dataset->zoomInDomain(r,chartGeometry().size());
+                m_state = ShowState;
-                if (m_animator)
-                    m_animator->setState(ChartAnimator::ShowState);
             }
             void ChartPresenter::zoomOut(qreal factor)
             {
-                if (m_animator)
+                m_state = ZoomOutState;
-                    m_animator->setState(ChartAnimator::ZoomOutState);
                 QRectF chartRect;
                 chartRect.setSize(chartGeometry().size());
                 QRectF rect;
                 rect.setSize(chartRect.size()/factor);
                 rect.moveCenter(chartRect.center());
                 if (!rect.isValid())
                     return;
+                m_statePoint = QPointF(rect.center().x()/chartGeometry().width(),rect.center().y()/chartGeometry().height());
                 m_dataset->zoomOutDomain(rect, chartRect.size());
+                m_state = ShowState;
-                if (m_animator)
-                    m_animator->setState(ChartAnimator::ShowState);
             }
             void ChartPresenter::scroll(int dx,int dy)
             {
-                if(m_animator){
-                    if(dx<0) m_animator->setState(ChartAnimator::ScrollLeftState,QPointF());
-                    if(dx>0) m_animator->setState(ChartAnimator::ScrollRightState,QPointF());
-                    if(dy<0) m_animator->setState(ChartAnimator::ScrollUpState,QPointF());
-                    if(dy>0) m_animator->setState(ChartAnimator::ScrollDownState,QPointF());
-                m_dataset->scrollDomain(dx,dy,chartGeometry().size());
+                if(dx<0) m_state=ScrollLeftState;
+                if(dx>0) m_state=ScrollRightState;
+                if(dy<0) m_state=ScrollUpState;
+                if(dy>0) m_state=ScrollDownState;
-                if(m_animator){
+                m_dataset->scrollDomain(dx,dy,chartGeometry().size());
-                    m_animator->setState(ChartAnimator::ShowState);
+                m_state = ShowState;
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::updateLayout()
             {
                 if (!m_rect.isValid()) return;
                 // recalculate title size
                 QSize titleSize;
                 int titlePadding=0;
                 if (m_titleItem) {
                     titleSize= m_titleItem->boundingRect().size().toSize();
                 }
                 //defaults
                 m_chartMargins = QRect(QPoint(m_minLeftMargin>m_marginBig?m_minLeftMargin:m_marginBig,m_marginBig),QPoint(m_marginBig,m_minBottomMargin>m_marginBig?m_minBottomMargin:m_marginBig));
                 titlePadding = m_chartMargins.top()/2;
                 QLegend* legend = m_chart->d_ptr->m_legend;
                 // recalculate legend position
                 if (legend->isAttachedToChart() && legend->isEnabled()) {
                     QRect legendRect;
                     // Reserve some space for legend
                     switch (legend->alignment()) {
                     case QLegend::AlignmentTop: {
                         int ledgendSize = legend->minHeight();
                         int topPadding = 2*m_marginTiny + titleSize.height() + ledgendSize + m_marginTiny;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),topPadding),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_chartMargins.left(),topPadding - (ledgendSize + m_marginTiny)),QPoint(m_chartMargins.right(),m_rect.height()-topPadding + m_marginTiny));
                         titlePadding = m_marginTiny + m_marginTiny;
                         break;
                     }
                     case QLegend::AlignmentBottom: {
                         int ledgendSize = legend->minHeight();
                         int bottomPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny + m_minBottomMargin;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(m_chartMargins.right(),bottomPadding));
                         m_legendMargins = QRect(QPoint(m_chartMargins.left(),m_rect.height()-bottomPadding + m_marginTiny + m_minBottomMargin),QPoint(m_chartMargins.right(),m_marginTiny + m_marginSmall));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     case QLegend::AlignmentLeft: {
                         int ledgendSize = legend->minWidth();
                         int leftPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny + m_minLeftMargin;
                         m_chartMargins = QRect(QPoint(leftPadding,m_chartMargins.top()),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_marginTiny + m_marginSmall,m_chartMargins.top()),QPoint(m_rect.width()-leftPadding + m_marginTiny + m_minLeftMargin,m_chartMargins.bottom()));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     case QLegend::AlignmentRight: {
                         int ledgendSize = legend->minWidth();
                         int rightPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(rightPadding,m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_rect.width()- rightPadding+ m_marginTiny ,m_chartMargins.top()),QPoint(m_marginTiny + m_marginSmall,m_chartMargins.bottom()));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     default: {
                         break;
                     }
                     }
                 }
                 if(m_rect.width()<2*(m_chartMargins.top()+m_chartMargins.bottom()) || m_rect.height()< 2*(m_chartMargins.top() + m_chartMargins.bottom()))
                 {
                     m_chart->setMinimumSize(2*(m_chartMargins.top()+m_chartMargins.bottom()),2*(m_chartMargins.top() + m_chartMargins.bottom()));
                     return;
                 }
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),titlePadding);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(m_rect.adjusted(m_marginTiny,m_marginTiny, -m_marginTiny, -m_marginTiny));
                 }
                 QRectF chartRect = m_rect.adjusted(m_chartMargins.left(),m_chartMargins.top(),-m_chartMargins.right(),-m_chartMargins.bottom());
                 legend->setGeometry(m_rect.adjusted(m_legendMargins.left(),m_legendMargins.top(),-m_legendMargins.right(),-m_legendMargins.bottom()));
                 if(m_chartRect!=chartRect && chartRect.isValid()){
                     m_chartRect=chartRect;
                     emit geometryChanged(m_chartRect);
                 }
             }
             void ChartPresenter::createChartBackgroundItem()
             {
                 if (!m_backgroundItem) {
                     m_backgroundItem = new ChartBackground(rootItem());
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createChartTitleItem()
             {
                 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()));
+            }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +20 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef 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 ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     ShadesZValue,
                     GridZValue,
                     LineChartZValue,
                     BarSeriesZValue,
                     ScatterSeriesZValue,
                     PieSeriesZValue,
                     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; }
                 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(int dx,int dy);
                 void setGeometry(const QRectF& rect);
                 QRectF chartGeometry() const { return m_chartRect; }
                 void setMinimumMarginHeight(ChartAxis* axis, qreal height);
                 void setMinimumMarginWidth(ChartAxis* axis, qreal width);
                 qreal minimumLeftMargin() const { return m_minLeftMargin; }
                 qreal minimumBottomMargin() const { return m_minBottomMargin; }
+                void startAnimation(ChartAnimation* animation);
+                State state() const { return m_state; }
+                QPointF statePoint() const { return m_statePoint; }
             public: //TODO: fix me
                 void resetAllElements();
                 void createChartBackgroundItem();
                 void createChartTitleItem();
                 QRectF margins() const { return m_chartMargins;}
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries* series,Domain* domain);
                 void handleSeriesRemoved(QAbstractSeries* series);
                 void handleAxisAdded(QAxis* axis,Domain* domain);
                 void handleAxisRemoved(QAxis* axis);
                 void updateLayout();
+            private Q_SLOTS:
+                void handleAnimationFinished();
             Q_SIGNALS:
                 void geometryChanged(const QRectF& rect);
+                void animationsFinished();
             private:
                 QChart* m_chart;
                 ChartAnimator* m_animator;
                 ChartDataSet* m_dataset;
                 ChartTheme *m_chartTheme;
                 QMap<QAbstractSeries *, Chart *> m_chartItems;
                 QMap<QAxis *, ChartAxis *> m_axisItems;
                 QRectF m_rect;
                 QRectF m_chartRect;
                 QChart::AnimationOptions m_options;
                 qreal m_minLeftMargin;
                 qreal m_minBottomMargin;
+                State m_state;
+                QPointF m_statePoint;
+                QList<ChartAnimation*> m_animations;
             public: //TODO: fixme
                 ChartBackground* m_backgroundItem;
                 QGraphicsSimpleTextItem* m_titleItem;
                 int m_marginBig;
                 int m_marginSmall;
                 int m_marginTiny;
                 QRectF m_chartMargins;
                 QRectF m_legendMargins;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

src/splinechart/splinechartitem.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 "splinechartitem_p.h"
             #include "qsplineseries_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_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()));
                 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);
             }
             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->setValues(oldPoints,newPoints,m_controlPoints,controlPoints,index);
-                    animator()->startAnimation(m_animation);
+                    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)) {
                     m_path = QPainterPath();
                     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()
             {
                 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/xychart/xychart.cpp +67 -32

             /****************************************************************************
              **
              ** 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 <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_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->d_func(),SIGNAL(reinitialized()),this,SLOT(handleReinitialized()));
                 QObject::connect(this,SIGNAL(clicked(QPointF)),series,SIGNAL(clicked(QPointF)));
             }
-            void XYChart::setGeometryPoints(QVector<QPointF>& points)
+            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->setValues(oldPoints, newPoints, index);
-                    animator()->startAnimation(m_animation);
+                    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 = m_points;
-                QPointF point;
-                point = calculateGeometryPoint(index);
-                points.insert(index, point);
-                if(m_animation) {
+                QVector<QPointF> points;
-                    m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
+            	if(m_animation) {
+            		m_animation->setAnimationType(XYAnimation::AddPointAnimation);
+            	}
-               updateChart(m_points,points,index);
+            	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() + 1);
+            	Q_ASSERT(index<=m_series->count());
-                Q_ASSERT(index>=0);
+            	Q_ASSERT(index>=0);
-                QVector<QPointF> points = m_points;
-                points.remove(index);
-                if(m_animation) {
+            	QVector<QPointF> points;
-                    m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
-                updateChart(m_points,points,index);
+            	if(m_animation) {
+            		m_animation->setAnimationType(XYAnimation::RemovePointAnimation);
+            	}
+            	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<m_series->count());
-                Q_ASSERT(index>=0);
+            	Q_ASSERT(index>=0);
-                QPointF point = calculateGeometryPoint(index);
-                QVector<QPointF> points = m_points;
-                points.replace(index,point);
-                if(m_animation) {
+            	QVector<QPointF> points;
-                    m_animation->setAnimationType(XYAnimation::MoveDownAnimation);
-                updateChart(m_points,points,index);
+            	if(m_animation) {
+            		m_animation->setAnimationType(XYAnimation::ReplacePointAnimation);
+            	}
+            	if(m_dirty) {
+            		points = calculateGeometryPoints();
+            	} else {
+            		QPointF point = calculateGeometryPoint(index);
+            		points = m_points;
+            		points.replace(index,point);
+            	}
+            	updateChart(m_points,points,index);
             }
             void XYChart::handleReinitialized()
             {
                 QVector<QPointF> points = calculateGeometryPoints();
                 if(m_animation) {
-                    m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
+                    m_animation->setAnimationType(XYAnimation::NewAnimation);
                 }
                 updateChart(m_points,points);
             }
             void XYChart::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
+                qDebug()<<__FUNCTION__;
                 m_minX=minX;
                 m_maxX=maxX;
                 m_minY=minY;
                 m_maxY=maxY;
                 if (isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 if(m_animation) {
-                    m_animation->setAnimationType(XYAnimation::MoveDownAnimation);
+                    m_animation->setAnimationType(XYAnimation::ReplacePointAnimation);
                 }
                 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();
                 if(m_animation) {
-                      m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
+                      m_animation->setAnimationType(XYAnimation::NewAnimation);
+                }
                 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/xychart/xychart_p.h +5 -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$
             **
             ****************************************************************************/
             #ifndef XYCHARTITEM_H
             #define XYCHARTITEM_H
             #include "qchartglobal.h"
             #include "chartitem_p.h"
             #include "xyanimation_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QXYSeries;
             class XYChart :  public Chart
             {
                  Q_OBJECT
             public:
                  explicit XYChart(QXYSeries *series, ChartPresenter *presenter);
                 ~XYChart(){};
-                void setGeometryPoints(QVector<QPointF>& points);
+                void setGeometryPoints(const QVector<QPointF>& points);
                 QVector<QPointF> geometryPoints() const { return m_points; }
                 void setClipRect(const QRectF &rect);
                 QRectF clipRect() const { return m_clipRect; }
                 QSizeF size() const { return m_size; }
                 QPointF origin() const { return m_origin; }
                 void setAnimation(XYAnimation* animation);
                 ChartAnimation* animation() const { return m_animation; }
                 virtual void updateGeometry() = 0;
+                bool isDirty() const { return m_dirty; }
+                void setDirty(bool dirty);
             public Q_SLOTS:
                 void handlePointAdded(int index);
                 void handlePointRemoved(int index);
                 void handlePointReplaced(int index);
                 void handleReinitialized();
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF &size);
             Q_SIGNALS:
                 void clicked(const QPointF& point);
             protected:
                 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;
                 QVector<QPointF> calculateGeometryPoints() const;
             private:
                 inline bool isEmpty();
             private:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 QXYSeries* m_series;
                 QSizeF m_size;
                 QPointF m_origin;
                 QRectF m_clipRect;
                 QVector<QPointF> m_points;
                 XYAnimation* m_animation;
+                bool m_dirty;
                 friend class AreaChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

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