HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2804:97642714ab1e

0

src/charts/animations/axisanimation.cpp +3 -3

             QT_CHARTS_BEGIN_NAMESPACE
-            AxisAnimation::AxisAnimation(ChartAxisElement *axis)
+            AxisAnimation::AxisAnimation(ChartAxisElement *axis, int duration, QEasingCurve &curve)
                 : ChartAnimation(axis),
                   m_axis(axis),
                   m_type(DefaultAnimation)
             {
-                setDuration(ChartAnimationDuration);
+                setDuration(duration);
-                setEasingCurve(QEasingCurve::OutQuart);
+                setEasingCurve(curve);
             }
             AxisAnimation::~AxisAnimation()

0

src/charts/animations/axisanimation_p.h +1 -1

             {
             public:
                 enum Animation { DefaultAnimation, ZoomOutAnimation, ZoomInAnimation, MoveForwardAnimation, MoveBackwordAnimation};
-                AxisAnimation(ChartAxisElement *axis);
+                AxisAnimation(ChartAxisElement *axis, int duration, QEasingCurve &curve);
                 ~AxisAnimation();
                 void setAnimationType(Animation type);
                 void setAnimationPoint(const QPointF &point);

0

src/charts/animations/baranimation.cpp +3 -3

             QT_CHARTS_BEGIN_NAMESPACE
-            BarAnimation::BarAnimation(AbstractBarChartItem *item)
+            BarAnimation::BarAnimation(AbstractBarChartItem *item, int duration, QEasingCurve &curve)
                 : ChartAnimation(item),
                   m_item(item)
             {
-                setDuration(ChartAnimationDuration);
+                setDuration(duration);
-                setEasingCurve(QEasingCurve::OutQuart);
+                setEasingCurve(curve);
             }
             BarAnimation::~BarAnimation()

0

src/charts/animations/baranimation_p.h +1 -1

                 Q_OBJECT
             public:
-                BarAnimation(AbstractBarChartItem *item);
+                BarAnimation(AbstractBarChartItem *item, int duration, QEasingCurve &curve);
                 ~BarAnimation();
             public: // from QVariantAnimation

0

src/charts/animations/boxplotanimation.cpp +6 -3

             QT_CHARTS_BEGIN_NAMESPACE
-            BoxPlotAnimation::BoxPlotAnimation(BoxPlotChartItem *item)
+            BoxPlotAnimation::BoxPlotAnimation(BoxPlotChartItem *item, int duration, QEasingCurve &curve)
                 : QObject(item),
-                m_item(item)
+                m_item(item),
+                m_animationDuration(duration),
+                m_animationCurve(curve)
             {
             }
             {
                 BoxWhiskersAnimation *animation = m_animations.value(box);
                 if (!animation) {
-                    animation = new BoxWhiskersAnimation(box, this);
+                    animation = new BoxWhiskersAnimation(box, this, m_animationDuration, m_animationCurve);
                     m_animations.insert(box, animation);
                     BoxWhiskersData start;
                     start.m_lowerExtreme = box->m_data.m_median;
                     start.m_upperQuartile = box->m_data.m_median;
                     start.m_upperExtreme = box->m_data.m_median;
                     animation->setup(start, box->m_data);
                 } else {
                     animation->stop();
                     animation->setEndData(box->m_data);

0

src/charts/animations/boxplotanimation_p.h +3 -1

             {
                 Q_OBJECT
             public:
-                BoxPlotAnimation(BoxPlotChartItem *item);
+                BoxPlotAnimation(BoxPlotChartItem *item, int duration, QEasingCurve &curve);
                 ~BoxPlotAnimation();
                 void addBox(BoxWhiskers *box);
             protected:
                 BoxPlotChartItem *m_item;
                 QHash<BoxWhiskers *, BoxWhiskersAnimation *> m_animations;
+                int m_animationDuration;
+                QEasingCurve m_animationCurve;
             };
             QT_CHARTS_END_NAMESPACE

0

src/charts/animations/boxwhiskersanimation.cpp +4 -3

             QT_CHARTS_BEGIN_NAMESPACE
-            BoxWhiskersAnimation::BoxWhiskersAnimation(BoxWhiskers *box, BoxPlotAnimation *boxPlotAnimation)
+            BoxWhiskersAnimation::BoxWhiskersAnimation(BoxWhiskers *box, BoxPlotAnimation *boxPlotAnimation,
+                                                       int duration, QEasingCurve &curve)
                 : ChartAnimation(box),
                   m_box(box),
                   m_changeAnimation(false),
                   m_boxPlotAnimation(boxPlotAnimation)
             {
-                setDuration(ChartAnimationDuration);
+                setDuration(duration);
-                setEasingCurve(QEasingCurve::OutQuart);
+                setEasingCurve(curve);
             }
             BoxWhiskersAnimation::~BoxWhiskersAnimation()

0

src/charts/animations/boxwhiskersanimation_p.h +2 -1

                 Q_OBJECT
             public:
-                BoxWhiskersAnimation(BoxWhiskers *box, BoxPlotAnimation *boxPlotAnimation);
+                BoxWhiskersAnimation(BoxWhiskers *box, BoxPlotAnimation *boxPlotAnimation, int duration,
+                                     QEasingCurve &curve);
                 ~BoxWhiskersAnimation();
             public: // from QVariantAnimation

0

src/charts/animations/pieanimation.cpp +8 -8

             QT_CHARTS_BEGIN_NAMESPACE
-            PieAnimation::PieAnimation(PieChartItem *item)
+            PieAnimation::PieAnimation(PieChartItem *item, int duration, QEasingCurve &curve)
                 : ChartAnimation(item),
-                  m_item(item)
+                  m_item(item),
+                  m_animationDuration(duration),
+                  m_animationCurve(curve)
             {
             }
                 PieSliceAnimation *animation = m_animations.value(sliceItem);
                 if (!animation) {
                     animation = new PieSliceAnimation(sliceItem);
+                    animation->setDuration(m_animationDuration);
+                    animation->setEasingCurve(m_animationCurve);
                     m_animations.insert(sliceItem, animation);
                 } else {
                     animation->stop();
                 }
                 animation->updateValue(sliceData);
-                animation->setDuration(ChartAnimationDuration);
-                animation->setEasingCurve(QEasingCurve::OutQuart);
                 return animation;
             }
             ChartAnimation *PieAnimation::addSlice(PieSliceItem *sliceItem, const PieSliceData &sliceData, bool startupAnimation)
             {
                 PieSliceAnimation *animation = new PieSliceAnimation(sliceItem);
+                animation->setDuration(m_animationDuration);
+                animation->setEasingCurve(m_animationCurve);
                 m_animations.insert(sliceItem, animation);
                 PieSliceData startValue = sliceData;
                     startValue.m_radius = sliceData.m_holeRadius;
                 animation->setValue(startValue, sliceData);
-                animation->setDuration(ChartAnimationDuration);
-                animation->setEasingCurve(QEasingCurve::OutQuart);
                 return animation;
             }
                 endValue.m_isLabelVisible = false;
                 animation->updateValue(endValue);
-                animation->setDuration(ChartAnimationDuration);
-                animation->setEasingCurve(QEasingCurve::OutQuart);
                 // PieSliceItem is the parent of PieSliceAnimation so the animation will be deleted as well..
                 connect(animation, SIGNAL(finished()), sliceItem, SLOT(deleteLater()));

0

src/charts/animations/pieanimation_p.h +3 -1

                 Q_OBJECT
             public:
-                PieAnimation(PieChartItem *item);
+                PieAnimation(PieChartItem *item, int duration, QEasingCurve &curve);
                 ~PieAnimation();
                 ChartAnimation *updateValue(PieSliceItem *sliceItem, const PieSliceData &newValue);
                 ChartAnimation *addSlice(PieSliceItem *sliceItem, const PieSliceData &endValue, bool startupAnimation);
             private:
                 PieChartItem *m_item;
                 QHash<PieSliceItem *, PieSliceAnimation *> m_animations;
+                int m_animationDuration;
+                QEasingCurve m_animationCurve;
             };
             QT_CHARTS_END_NAMESPACE

0

src/charts/animations/scatteranimation.cpp +2 -2

             QT_CHARTS_BEGIN_NAMESPACE
-            ScatterAnimation::ScatterAnimation(ScatterChartItem *item)
+            ScatterAnimation::ScatterAnimation(ScatterChartItem *item, int duration, QEasingCurve &curve)
-                : XYAnimation(item)
+                : XYAnimation(item, duration, curve)
             {
             }

0

src/charts/animations/scatteranimation_p.h +1 -1

             class ScatterAnimation : public XYAnimation
             {
             public:
-                ScatterAnimation(ScatterChartItem *item);
+                ScatterAnimation(ScatterChartItem *item, int duration, QEasingCurve &curve);
                 ~ScatterAnimation();
             protected:

0

src/charts/animations/splineanimation.cpp +2 -2

             QT_CHARTS_BEGIN_NAMESPACE
-            SplineAnimation::SplineAnimation(SplineChartItem *item)
+            SplineAnimation::SplineAnimation(SplineChartItem *item, int duration, QEasingCurve &curve)
-                : XYAnimation(item),
+                : XYAnimation(item, duration, curve),
                   m_item(item),
                   m_valid(false)
             {

0

src/charts/animations/splineanimation_p.h +1 -1

             class SplineAnimation : public XYAnimation
             {
             public:
-                SplineAnimation(SplineChartItem *item);
+                SplineAnimation(SplineChartItem *item, int duration, QEasingCurve &curve);
                 ~SplineAnimation();
                 void setup(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldContorlPoints, QVector<QPointF> &newControlPoints, int index = -1);

0

src/charts/animations/xyanimation.cpp +3 -3

             QT_CHARTS_BEGIN_NAMESPACE
-            XYAnimation::XYAnimation(XYChart *item)
+            XYAnimation::XYAnimation(XYChart *item, int duration, QEasingCurve &curve)
                 : ChartAnimation(item),
                   m_type(NewAnimation),
                   m_dirty(false),
                   m_index(-1),
                   m_item(item)
             {
-                setDuration(ChartAnimationDuration);
+                setDuration(duration);
-                setEasingCurve(QEasingCurve::OutQuart);
+                setEasingCurve(curve);
             }
             XYAnimation::~XYAnimation()

0

src/charts/animations/xyanimation_p.h +1 -1

             protected:
                 enum Animation { AddPointAnimation, RemovePointAnimation, ReplacePointAnimation, NewAnimation };
             public:
-                XYAnimation(XYChart *item);
+                XYAnimation(XYChart *item, int duration, QEasingCurve &curve);
                 ~XYAnimation();
                 void setup(const QVector<QPointF> &oldPoints, const QVector<QPointF> &newPoints, int index = -1);
                 Animation animationType() const { return m_type; };

0

src/charts/areachart/qareaseries.cpp +7 -4

                 m_item.reset(area);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
-            void  QAreaSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
+            void  QAreaSeriesPrivate::initializeAnimations(QChart::AnimationOptions options, int duration,
+                                                           QEasingCurve &curve)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem *area = static_cast<AreaChartItem *>(m_item.data());
                     area->lowerLineItem()->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations)) {
-                    area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem()));
+                    area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem(), duration,
+                                                                        curve));
                     if (q->lowerSeries())
-                        area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem()));
+                        area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem(), duration,
+                                                                            curve));
                 } else {
                     if (q->upperSeries())
                         area->upperLineItem()->setAnimation(0);
                     if (q->lowerSeries())
                            area->lowerLineItem()->setAnimation(0);
                 }
-                QAbstractSeriesPrivate::initializeAnimations(options);
+                QAbstractSeriesPrivate::initializeAnimations(options, duration, curve);
             }
             QList<QLegendMarker*> QAreaSeriesPrivate::createLegendMarkers(QLegend* legend)

0

src/charts/areachart/qareaseries_p.h +2 -1

                 void initializeAxes();
                 void initializeGraphics(QGraphicsItem* parent);
                 void initializeTheme(int index, ChartTheme* theme, bool forced = false);
-                void initializeAnimations(QChart::AnimationOptions options);
+                void initializeAnimations(QChart::AnimationOptions options, int duration,
+                                          QEasingCurve &curve);
                 QList<QLegendMarker *> createLegendMarkers(QLegend *legend);

0

src/charts/axis/qabstractaxis.cpp +3 -2

                 Q_UNUSED(parent);
             }
-            void QAbstractAxisPrivate::initializeAnimations(QChart::AnimationOptions options)
+            void QAbstractAxisPrivate::initializeAnimations(QChart::AnimationOptions options, int duration,
+                                                            QEasingCurve &curve)
             {
                 ChartAxisElement *axis = m_item.data();
                 Q_ASSERT(axis);
                     axis->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::GridAxisAnimations))
-                    axis->setAnimation(new AxisAnimation(axis));
+                    axis->setAnimation(new AxisAnimation(axis, duration, curve));
                 else
                     axis->setAnimation(0);
             }

0

src/charts/axis/qabstractaxis_p.h +2 -1

                 virtual void initializeDomain(AbstractDomain *domain) = 0;
                 virtual void initializeGraphics(QGraphicsItem *parent) = 0;
                 virtual void initializeTheme(ChartTheme* theme, bool forced = false);
-                virtual void initializeAnimations(QChart::AnimationOptions options);
+                virtual void initializeAnimations(QChart::AnimationOptions options, int duration,
+                                                  QEasingCurve &curve);
                 //interface for manipulating range form base class
                 virtual void setMin(const QVariant &min) = 0;

0

src/charts/barchart/qabstractbarseries.cpp +4 -3

                 emit updatedBars();
             }
-            void QAbstractBarSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
+            void QAbstractBarSeriesPrivate::initializeAnimations(QChart::AnimationOptions options, int duration,
+                                                                 QEasingCurve &curve)
             {
                 AbstractBarChartItem *bar = static_cast<AbstractBarChartItem *>(m_item.data());
                 Q_ASSERT(bar);
                     bar->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
-                    bar->setAnimation(new BarAnimation(bar));
+                    bar->setAnimation(new BarAnimation(bar, duration, curve));
                 else
                     bar->setAnimation(0);
-                QAbstractSeriesPrivate::initializeAnimations(options);
+                QAbstractSeriesPrivate::initializeAnimations(options, duration, curve);
             }
             #include "moc_qabstractbarseries.cpp"

0

src/charts/barchart/qabstractbarseries_p.h +1 -1

                 void initializeDomain();
                 void initializeAxes();
-                void initializeAnimations(QChart::AnimationOptions options);
+                void initializeAnimations(QChart::AnimationOptions options, int duration, QEasingCurve &curve);
                 void initializeTheme(int index, ChartTheme* theme, bool forced = false);
                 QList<QLegendMarker*> createLegendMarkers(QLegend *legend);

0

src/charts/boxplotchart/qboxplotseries.cpp +7 -3

                 }
             }
-            void QBoxPlotSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
+            void QBoxPlotSeriesPrivate::initializeAnimations(QChart::AnimationOptions options, int duration,
+                                                             QEasingCurve &curve)
             {
                 BoxPlotChartItem *item = static_cast<BoxPlotChartItem *>(m_item.data());
                 Q_ASSERT(item);
                     item->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
-                    m_animation = new BoxPlotAnimation(item);
+                    m_animation = new BoxPlotAnimation(item, duration, curve);
                 else
                     m_animation = 0;
                 item->setAnimation(m_animation);
-                QAbstractSeriesPrivate::initializeAnimations(options);
+                QAbstractSeriesPrivate::initializeAnimations(options, duration, curve);
+                // Make BoxPlotChartItem to instantiate box & whisker items
+                item->handleDataStructureChanged();
             }
             QList<QLegendMarker*> QBoxPlotSeriesPrivate::createLegendMarkers(QLegend *legend)

0

src/charts/boxplotchart/qboxplotseries_p.h +1 -1

                 void initializeGraphics(QGraphicsItem *parent);
                 void initializeDomain();
                 void initializeAxes();
-                void initializeAnimations(QChart::AnimationOptions options);
+                void initializeAnimations(QChart::AnimationOptions options, int duration, QEasingCurve &curve);
                 void initializeTheme(int index, ChartTheme *theme, bool forced = false);
                 QList<QLegendMarker*> createLegendMarkers(QLegend *legend);

0

src/charts/chartpresenter.cpp +31 -4

                 : QObject(chart),
                   m_chart(chart),
                   m_options(QChart::NoAnimation),
+                  m_animationDuration(ChartAnimationDuration),
+                  m_animationCurve(QEasingCurve::OutQuart),
                   m_state(ShowState),
                   m_background(0),
                   m_plotAreaBackground(0),
             void ChartPresenter::handleAxisAdded(QAbstractAxis *axis)
             {
                 axis->d_ptr->initializeGraphics(rootItem());
-                axis->d_ptr->initializeAnimations(m_options);
+                axis->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                 ChartAxisElement *item = axis->d_ptr->axisItem();
                 item->setPresenter(this);
                 item->setThemeManager(m_chart->d_ptr->m_themeManager);
             void ChartPresenter::handleSeriesAdded(QAbstractSeries *series)
             {
                 series->d_ptr->initializeGraphics(rootItem());
-                series->d_ptr->initializeAnimations(m_options);
+                series->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                 series->d_ptr->setPresenter(this);
                 ChartItem *chart = series->d_ptr->chartItem();
                 chart->setPresenter(this);
                     m_options = options;
                     if (options.testFlag(QChart::SeriesAnimations) != oldOptions.testFlag(QChart::SeriesAnimations)) {
                         foreach (QAbstractSeries *series, m_series)
-                            series->d_ptr->initializeAnimations(m_options);
+                            series->d_ptr->initializeAnimations(m_options, m_animationDuration,
+                                                                m_animationCurve);
                     }
                     if (options.testFlag(QChart::GridAxisAnimations) != oldOptions.testFlag(QChart::GridAxisAnimations)) {
                         foreach (QAbstractAxis *axis, m_axes)
-                            axis->d_ptr->initializeAnimations(m_options);
+                            axis->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                     }
                     m_layout->invalidate(); // So that existing animations don't just stop halfway
                 }
             }
+            void ChartPresenter::setAnimationDuration(int msecs)
+            {
+                if (m_animationDuration != msecs) {
+                    m_animationDuration = msecs;
+                    foreach (QAbstractSeries *series, m_series)
+                        series->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
+                    foreach (QAbstractAxis *axis, m_axes)
+                        axis->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
+                    m_layout->invalidate(); // So that existing animations don't just stop halfway
+                }
+            }
+            void ChartPresenter::setAnimationEasingCurve(const QEasingCurve &curve)
+            {
+                if (m_animationCurve != curve) {
+                    m_animationCurve = curve;
+                    foreach (QAbstractSeries *series, m_series)
+                        series->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
+                    foreach (QAbstractAxis *axis, m_axes)
+                        axis->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
+                    m_layout->invalidate(); // So that existing animations don't just stop halfway
+                }
+            }
             void ChartPresenter::setState(State state,QPointF point)
             {
             	m_state=state;

0

src/charts/chartpresenter_p.h +6 0

                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
+                void setAnimationDuration(int msecs);
+                int animationDuration() const { return m_animationDuration; }
+                void setAnimationEasingCurve(const QEasingCurve &curve);
+                QEasingCurve animationEasingCurve() const { return m_animationCurve; }
                 void startAnimation(ChartAnimation *animation);
                 QList<QAbstractSeries *> m_series;
                 QList<QAbstractAxis *> m_axes;
                 QChart::AnimationOptions m_options;
+                int m_animationDuration;
+                QEasingCurve m_animationCurve;
                 State m_state;
                 QPointF m_statePoint;
                 AbstractChartLayout *m_layout;

0

src/charts/piechart/qpieseries.cpp +4 -3

                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
-            void QPieSeriesPrivate::initializeAnimations(QtCharts::QChart::AnimationOptions options)
+            void QPieSeriesPrivate::initializeAnimations(QtCharts::QChart::AnimationOptions options,
+                                                         int duration, QEasingCurve &curve)
             {
                 PieChartItem *item = static_cast<PieChartItem *>(m_item.data());
                 Q_ASSERT(item);
                     item->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
-                    item->setAnimation(new PieAnimation(item));
+                    item->setAnimation(new PieAnimation(item, duration, curve));
                 else
                     item->setAnimation(0);
-                QAbstractSeriesPrivate::initializeAnimations(options);
+                QAbstractSeriesPrivate::initializeAnimations(options, duration, curve);
             }
             QList<QLegendMarker*> QPieSeriesPrivate::createLegendMarkers(QLegend* legend)

0

src/charts/piechart/qpieseries_p.h +2 -1

                 void initializeDomain();
                 void initializeAxes();
                 void initializeGraphics(QGraphicsItem* parent);
-                void initializeAnimations(QtCharts::QChart::AnimationOptions options);
+                void initializeAnimations(QtCharts::QChart::AnimationOptions options, int duration,
+                                          QEasingCurve &curve);
                 void initializeTheme(int index, ChartTheme* theme, bool forced = false);
                 QList<QLegendMarker *> createLegendMarkers(QLegend *legend);

0

src/charts/qabstractseries.cpp +4 -1

                 QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
             }
-            void QAbstractSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
+            void QAbstractSeriesPrivate::initializeAnimations(QChart::AnimationOptions options, int duration,
+                                                              QEasingCurve &curve)
             {
                 Q_UNUSED(options);
+                Q_UNUSED(duration);
+                Q_UNUSED(curve);
             }
             bool QAbstractSeriesPrivate::reverseXAxis()

0

src/charts/qabstractseries_p.h +2 -1

                 virtual void initializeAxes() = 0;
                 virtual void initializeTheme(int index, ChartTheme* theme, bool forced = false) = 0;
                 virtual void initializeGraphics(QGraphicsItem* parent) = 0;
-                virtual void initializeAnimations(QChart::AnimationOptions options) = 0;
+                virtual void initializeAnimations(QChart::AnimationOptions options, int duration,
+                                                  QEasingCurve &curve) = 0;
                 virtual QList<QLegendMarker*> createLegendMarkers(QLegend* legend) = 0;

0

src/charts/qchart.cpp +30 0

@@ -85,6 +85,16 QT_CHARTS_BEGIN_NAMESPACE
85	*/	85	*/
86		86
87	/*!	87	/*!
		88	\property QChart::animationDuration
		89	The duration of the animation for the chart.
		90	*/
		91
		92	/*!
		93	\property QChart::animationEasingCurve
		94	The easing curve of the animation for the chart.
		95	*/
		96
		97	/*!
88	\property QChart::backgroundVisible	98	\property QChart::backgroundVisible
89	Specifies whether the chart background is visible or not.	99	Specifies whether the chart background is visible or not.
90	\sa setBackgroundBrush(), setBackgroundPen(), plotAreaBackgroundVisible	100	\sa setBackgroundBrush(), setBackgroundPen(), plotAreaBackgroundVisible
@@ -595,6 +605,26 QChart::AnimationOptions QChart::animationOptions() const
595	return d_ptr->m_presenter->animationOptions();	605	return d_ptr->m_presenter->animationOptions();
596	}	606	}
597		607
		608	void QChart::setAnimationDuration(int msecs)
		609	{
		610	d_ptr->m_presenter->setAnimationDuration(msecs);
		611	}
		612
		613	int QChart::animationDuration() const
		614	{
		615	return d_ptr->m_presenter->animationDuration();
		616	}
		617
		618	void QChart::setAnimationEasingCurve(const QEasingCurve &curve)
		619	{
		620	d_ptr->m_presenter->setAnimationEasingCurve(curve);
		621	}
		622
		623	QEasingCurve QChart::animationEasingCurve() const
		624	{
		625	return d_ptr->m_presenter->animationEasingCurve();
		626	}
		627
598	/*!	628	/*!
599	Scrolls the visible area of the chart by the distance defined in the \a dx and \a dy.	629	Scrolls the visible area of the chart by the distance defined in the \a dx and \a dy.
600		630

0

src/charts/qchart.h +7 0

                 Q_PROPERTY(bool dropShadowEnabled READ isDropShadowEnabled WRITE setDropShadowEnabled)
                 Q_PROPERTY(qreal backgroundRoundness READ backgroundRoundness WRITE setBackgroundRoundness)
                 Q_PROPERTY(QChart::AnimationOptions animationOptions READ animationOptions WRITE setAnimationOptions)
+                Q_PROPERTY(int animationDuration READ animationDuration WRITE setAnimationDuration)
+                Q_PROPERTY(QEasingCurve animationEasingCurve READ animationEasingCurve WRITE setAnimationEasingCurve)
                 Q_PROPERTY(QMargins margins READ margins WRITE setMargins)
                 Q_PROPERTY(QChart::ChartType chartType READ chartType)
                 Q_PROPERTY(bool plotAreaBackgroundVisible READ isPlotAreaBackgroundVisible WRITE setPlotAreaBackgroundVisible)
                 bool isDropShadowEnabled() const;
                 void setBackgroundRoundness(qreal diameter);
                 qreal backgroundRoundness() const;
                 void setAnimationOptions(AnimationOptions options);
                 AnimationOptions animationOptions() const;
+                void setAnimationDuration(int msecs);
+                int animationDuration() const;
+                void setAnimationEasingCurve(const QEasingCurve &curve);
+                QEasingCurve animationEasingCurve() const;
                 void zoomIn();
                 void zoomOut();

0

src/charts/scatterchart/qscatterseries.cpp +4 -3

                 }
             }
-            void QScatterSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
+            void QScatterSeriesPrivate::initializeAnimations(QChart::AnimationOptions options, int duration,
+                                                             QEasingCurve &curve)
             {
                 ScatterChartItem *item = static_cast<ScatterChartItem *>(m_item.data());
                 Q_ASSERT(item);
                     item->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
-                    item->setAnimation(new ScatterAnimation(item));
+                    item->setAnimation(new ScatterAnimation(item, duration, curve));
                 else
                     item->setAnimation(0);
-                QAbstractSeriesPrivate::initializeAnimations(options);
+                QAbstractSeriesPrivate::initializeAnimations(options, duration, curve);
             }
             #include "moc_qscatterseries.cpp"

0

src/charts/scatterchart/qscatterseries_p.h +2 -1

                 QScatterSeriesPrivate(QScatterSeries *q);
                 void initializeGraphics(QGraphicsItem* parent);
                 void initializeTheme(int index, ChartTheme* theme, bool forced = false);
-                void initializeAnimations(QtCharts::QChart::AnimationOptions options);
+                void initializeAnimations(QtCharts::QChart::AnimationOptions options, int duration,
+                                          QEasingCurve &curve);
             private:
                 QScatterSeries::MarkerShape m_shape;

0

src/charts/splinechart/qsplineseries.cpp +4 -3

                 }
             }
-            void QSplineSeriesPrivate::initializeAnimations(QtCharts::QChart::AnimationOptions options)
+            void QSplineSeriesPrivate::initializeAnimations(QtCharts::QChart::AnimationOptions options,
+                                                            int duration, QEasingCurve &curve)
             {
                 SplineChartItem *item = static_cast<SplineChartItem *>(m_item.data());
                 Q_ASSERT(item);
                     item->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
-                    item->setAnimation(new SplineAnimation(item));
+                    item->setAnimation(new SplineAnimation(item, duration, curve));
                 else
                     item->setAnimation(0);
-                QAbstractSeriesPrivate::initializeAnimations(options);
+                QAbstractSeriesPrivate::initializeAnimations(options, duration, curve);
             }
             #include "moc_qsplineseries.cpp"

0

src/charts/splinechart/qsplineseries_p.h +2 -1

                 void initializeTheme(int index, ChartTheme* theme, bool forced = false);
                 void initializeGraphics(QGraphicsItem* parent);
-                void initializeAnimations(QtCharts::QChart::AnimationOptions options);
+                void initializeAnimations(QtCharts::QChart::AnimationOptions options, int duration,
+                                          QEasingCurve &curve);
             private:
                 Q_DECLARE_PUBLIC(QSplineSeries)

0

src/charts/xychart/qxyseries.cpp +4 -3

                 return new QValueAxis;
             }
-            void QXYSeriesPrivate::initializeAnimations(QtCharts::QChart::AnimationOptions options)
+            void QXYSeriesPrivate::initializeAnimations(QtCharts::QChart::AnimationOptions options,
+                                                        int duration, QEasingCurve &curve)
             {
                 XYChart *item = static_cast<XYChart *>(m_item.data());
                 Q_ASSERT(item);
                     item->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
-                    item->setAnimation(new XYAnimation(item));
+                    item->setAnimation(new XYAnimation(item, duration, curve));
                 else
                     item->setAnimation(0);
-                QAbstractSeriesPrivate::initializeAnimations(options);
+                QAbstractSeriesPrivate::initializeAnimations(options, duration, curve);
             }
             void QXYSeriesPrivate::drawSeriesPointLabels(QPainter *painter, const QVector<QPointF> &points,

0

src/charts/xychart/qxyseries_p.h +2 -1

                 void initializeDomain();
                 void initializeAxes();
-                void initializeAnimations(QtCharts::QChart::AnimationOptions options);
+                void initializeAnimations(QtCharts::QChart::AnimationOptions options, int duration,
+                                          QEasingCurve &curve);
                 QList<QLegendMarker*> createLegendMarkers(QLegend* legend);

0

src/chartsqml2/declarativechart.cpp +35 0

@@ -81,6 +81,15 QT_CHARTS_BEGIN_NAMESPACE
81	*/	81	*/
82		82
83	/*!	83	/*!
		84	\qmlproperty int ChartView::animationDuration
		85	The duration of the animation for the chart.
		86	*/
		87
		88	/*!
		89	\qmlproperty easing ChartView::animationEasingCurve
		90	The easing curve of the animation for the chart.
		91
		92	/*!
84	\qmlproperty Font ChartView::titleFont	93	\qmlproperty Font ChartView::titleFont
85	The title font of the chart.	94	The title font of the chart.
86		95
@@ -673,6 +682,32 DeclarativeChart::Animation DeclarativeChart::animationOptions()
673	return DeclarativeChart::NoAnimation;	682	return DeclarativeChart::NoAnimation;
674	}	683	}
675		684
		685	void DeclarativeChart::setAnimationDuration(int msecs)
		686	{
		687	if (msecs != m_chart->animationDuration()) {
		688	m_chart->setAnimationDuration(msecs);
		689	emit animationDurationChanged(msecs);
		690	}
		691	}
		692
		693	int DeclarativeChart::animationDuration() const
		694	{
		695	return m_chart->animationDuration();
		696	}
		697
		698	void DeclarativeChart::setAnimationEasingCurve(const QEasingCurve &curve)
		699	{
		700	if (curve != m_chart->animationEasingCurve()) {
		701	m_chart->setAnimationEasingCurve(curve);
		702	emit animationEasingCurveChanged(curve);
		703	}
		704	}
		705
		706	QEasingCurve DeclarativeChart::animationEasingCurve() const
		707	{
		708	return m_chart->animationEasingCurve();
		709	}
		710
676	void DeclarativeChart::setTitle(QString title)	711	void DeclarativeChart::setTitle(QString title)
677	{	712	{
678	if (title != m_chart->title())	713	if (title != m_chart->title())

0

src/chartsqml2/declarativechart.h +8 0

                 Q_OBJECT
                 Q_PROPERTY(Theme theme READ theme WRITE setTheme)
                 Q_PROPERTY(Animation animationOptions READ animationOptions WRITE setAnimationOptions)
+                Q_PROPERTY(int animationDuration READ animationDuration WRITE setAnimationDuration NOTIFY animationDurationChanged REVISION 5)
+                Q_PROPERTY(QEasingCurve animationEasingCurve READ animationEasingCurve WRITE setAnimationEasingCurve NOTIFY animationEasingCurveChanged REVISION 5)
                 Q_PROPERTY(QString title READ title WRITE setTitle)
                 Q_PROPERTY(QFont titleFont READ titleFont WRITE setTitleFont)
                 Q_PROPERTY(QColor titleColor READ titleColor WRITE setTitleColor NOTIFY titleColorChanged)
                 DeclarativeChart::Theme theme();
                 void setAnimationOptions(DeclarativeChart::Animation animations);
                 DeclarativeChart::Animation animationOptions();
+                void setAnimationDuration(int msecs);
+                int animationDuration() const;
+                void setAnimationEasingCurve(const QEasingCurve &curve);
+                QEasingCurve animationEasingCurve() const;
                 void setTitle(QString title);
                 QString title();
                 QLegend *legend();
                 Q_REVISION(3) void backgroundRoundnessChanged(qreal diameter);
                 Q_REVISION(4) void localizeNumbersChanged();
                 Q_REVISION(4) void localeChanged();
+                Q_REVISION(5) void animationDurationChanged(int msecs);
+                Q_REVISION(5) void animationEasingCurveChanged(QEasingCurve curve);
             private Q_SLOTS:
                 void changeMargins(int top, int bottom, int left, int right);

0

src/chartsqml2/plugins.qmltypes +12 0

                     Property { name: "axes"; revision: 2; type: "QAbstractAxis"; isList: true; isReadonly: true }
                     Property { name: "localizeNumbers"; revision: 4; type: "bool" }
                     Property { name: "locale"; revision: 4; type: "QLocale" }
+                    Property { name: "animationDuration"; revision: 5; type: "int" }
+                    Property { name: "animationEasingCurve"; revision: 5; type: "QEasingCurve" }
                     Signal { name: "axisLabelsChanged" }
                     Signal {
                         name: "titleColorChanged"
                     }
                     Signal { name: "localizeNumbersChanged"; revision: 4 }
                     Signal { name: "localeChanged"; revision: 4 }
+                    Signal {
+                        name: "animationDurationChanged"
+                        revision: 5
+                        Parameter { name: "msecs"; type: "int" }
+                    }
+                    Signal {
+                        name: "animationEasingCurveChanged"
+                        revision: 5
+                        Parameter { name: "curve"; type: "QEasingCurve" }
+                    }
                     Method {
                         name: "series"
                         type: "QAbstractSeries*"

0

tests/auto/qchart/tst_qchart.cpp +29 0

@@ -59,6 +59,9 private slots:
59	void addSeries();	59	void addSeries();
60	void animationOptions_data();	60	void animationOptions_data();
61	void animationOptions();	61	void animationOptions();
		62	void animationDuration();
		63	void animationCurve_data();
		64	void animationCurve();
62	void axisX_data();	65	void axisX_data();
63	void axisX();	66	void axisX();
64	void axisY_data();	67	void axisY_data();
@@ -160,6 +163,8 void tst_QChart::qchart()
160	QVERIFY(m_chart->legend()->isVisible());	163	QVERIFY(m_chart->legend()->isVisible());
161		164
162	QCOMPARE(m_chart->animationOptions(), QChart::NoAnimation);	165	QCOMPARE(m_chart->animationOptions(), QChart::NoAnimation);
		166	QCOMPARE(m_chart->animationDuration(), 1000);
		167	QCOMPARE(m_chart->animationEasingCurve(), QEasingCurve(QEasingCurve::OutQuart));
163	QVERIFY(!m_chart->axisX());	168	QVERIFY(!m_chart->axisX());
164	QVERIFY(!m_chart->axisY());	169	QVERIFY(!m_chart->axisY());
165	QVERIFY(m_chart->backgroundBrush()!=QBrush());	170	QVERIFY(m_chart->backgroundBrush()!=QBrush());
@@ -258,6 +263,30 void tst_QChart::animationOptions()
258	QCOMPARE(m_chart->animationOptions(), animationOptions);	263	QCOMPARE(m_chart->animationOptions(), animationOptions);
259	}	264	}
260		265
		266	void tst_QChart::animationDuration()
		267	{
		268	createTestData();
		269	m_chart->setAnimationDuration(2000);
		270	QVERIFY(m_chart->animationDuration() == 2000);
		271	}
		272
		273	void tst_QChart::animationCurve_data()
		274	{
		275	QTest::addColumn<QEasingCurve>("animationCurve");
		276	QTest::newRow("Linear") << QEasingCurve(QEasingCurve::Linear);
		277	QTest::newRow("InCubic") << QEasingCurve(QEasingCurve::InCubic);
		278	QTest::newRow("OutSine") << QEasingCurve(QEasingCurve::OutSine);
		279	QTest::newRow("OutInBack") << QEasingCurve(QEasingCurve::OutInBack);
		280	}
		281
		282	void tst_QChart::animationCurve()
		283	{
		284	createTestData();
		285	QFETCH(QEasingCurve, animationCurve);
		286	m_chart->setAnimationEasingCurve(animationCurve);
		287	QCOMPARE(m_chart->animationEasingCurve(), animationCurve);
		288	}
		289
261	void tst_QChart::axisX_data()	290	void tst_QChart::axisX_data()
262	{	291	{
263		292

0

tests/auto/qml-qtquicktest/tst_chartview.qml +2 0

                     function test_chartViewProperties() {
                         compare(chartView.animationOptions, ChartView.NoAnimation, "ChartView.animationOptions");
+                        compare(chartView.animationDuration, 1000, "ChartView.animationDuration");
+                        compare(chartView.animationEasingCurve.type, Easing.OutQuart, "ChartView.animationEasingCurve");
                         verify(chartView.backgroundColor != undefined);
                         verify(chartView.margins.bottom > 0, "ChartView.margins.bottom");
                         verify(chartView.margins.top > 0, "ChartView.margins.top");

0

tests/manual/qmlchartproperties/qml/qmlchartproperties/Chart.qml +6 -2

             ****************************************************************************/
             import QtQuick 2.0
-            import QtCharts 2.0
+            import QtCharts 2.1
             ChartView {
                 id: chartView
                 onBackgroundRoundnessChanged:      console.log("chart.onBackgroundRoundnessChanged: " + diameter);
                 onSeriesAdded:                     console.log("chart.onSeriesAdded: " + series.name);
                 onSeriesRemoved:                   console.log("chart.onSeriesRemoved: " + series.name);
-                onPlotAreaColorChanged:            console.log("chart.plotAreaColorChanged: " + chart.plotAreaColor);
+                onPlotAreaColorChanged:            console.log("chart.onPlotAreaColorChanged: " + chart.plotAreaColor);
+                onAnimationDurationChanged:        console.log("chart.onAnimationDurationChanged: "
+                                                               + chart.animationDuration);
+                onAnimationEasingCurveChanged:     console.log("chart.onAnimationEasingCurveChanged: "
+                                                               + chart.animationEasingCurve.type);
                 legend.onVisibleChanged:           console.log("legend.onVisibleChanged: " + chart.legend.visible);
                 legend.onBackgroundVisibleChanged: console.log("legend.onBackgroundVisibleChanged: " + visible);

0

tests/manual/qmlchartproperties/qml/qmlchartproperties/ChartEditorProperties.qml +20 0

@@ -21,8 +21,16 import QtQuick 2.0
21	Flow {	21	Flow {
22	anchors.fill: parent	22	anchors.fill: parent
23	property variant chart	23	property variant chart
		24	property variant easingTypes: [Easing.Linear, Easing.InCubic, Easing.OutSine, Easing.OutInBack]
		25	property int easingTypeIndex: 0
24	flow: Flow.TopToBottom	26	flow: Flow.TopToBottom
25	spacing: 5	27	spacing: 5
		28
		29	function nextEasingType() {
		30	easingTypeIndex++;
		31	return easingTypes[easingTypeIndex % easingTypes.length];
		32	}
		33
26	Button {	34	Button {
27	text: "visible"	35	text: "visible"
28	onClicked: chart.visible = !chart.visible;	36	onClicked: chart.visible = !chart.visible;
@@ -44,6 +52,18 Flow {
44	onClicked: chart.animationOptions--;	52	onClicked: chart.animationOptions--;
45	}	53	}
46	Button {	54	Button {
		55	text: "animation duration +"
		56	onClicked: chart.animationDuration = chart.animationDuration + 1000;
		57	}
		58	Button {
		59	text: "animation duration -"
		60	onClicked: chart.animationDuration = chart.animationDuration - 1000;
		61	}
		62	Button {
		63	text: "animation curve"
		64	onClicked: chart.animationEasingCurve.type = nextEasingType();
		65	}
		66	Button {
47	text: "background color"	67	text: "background color"
48	onClicked: chart.backgroundColor = main.nextColor();	68	onClicked: chart.backgroundColor = main.nextColor();
49	}	69	}

	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