HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2496:764230e0c100

Implement index based removing/replacing points in series...

Miikka Heikkinen -

r2496:764230e0c100

parent child

Context file:

r2496:764230e0c100

Collapse all files

plugins/declarative/declarativelineseries.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 DECLARATIVELINESERIES_H
             #define DECLARATIVELINESERIES_H
             #include "qlineseries.h"
             #include "declarativexyseries.h"
             #include "declarativeaxes.h"
             #include "shared_defines.h"
             #ifdef CHARTS_FOR_QUICK2
             #include <QtQml/QQmlListProperty>
             #include <QtQml/QQmlParserStatus>
             #else
             #include <QtDeclarative/QDeclarativeListProperty>
             #include <QtDeclarative/QDeclarativeParserStatus>
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeLineSeries : public QLineSeries, public DeclarativeXySeries, public QDECLARATIVE_PARSER_STATUS
             {
                 Q_OBJECT
             #ifdef CHARTS_FOR_QUICK2
                 Q_INTERFACES(QQmlParserStatus)
             #else
                 Q_INTERFACES(QDeclarativeParserStatus)
             #endif
                 Q_PROPERTY(int count READ count NOTIFY countChanged)
                 Q_PROPERTY(QAbstractAxis *axisX READ axisX WRITE setAxisX NOTIFY axisXChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY NOTIFY axisYChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisXTop READ axisXTop WRITE setAxisXTop NOTIFY axisXTopChanged REVISION 2)
                 Q_PROPERTY(QAbstractAxis *axisYRight READ axisYRight WRITE setAxisYRight NOTIFY axisYRightChanged REVISION 2)
                 Q_PROPERTY(QAbstractAxis *axisAngular READ axisAngular WRITE setAxisAngular NOTIFY axisAngularChanged REVISION 3)
                 Q_PROPERTY(QAbstractAxis *axisRadial READ axisRadial WRITE setAxisRadial NOTIFY axisRadialChanged REVISION 3)
                 Q_PROPERTY(qreal width READ width WRITE setWidth NOTIFY widthChanged REVISION 1)
                 Q_PROPERTY(Qt::PenStyle style READ style WRITE setStyle NOTIFY styleChanged REVISION 1)
                 Q_PROPERTY(Qt::PenCapStyle capStyle READ capStyle WRITE setCapStyle NOTIFY capStyleChanged REVISION 1)
             #ifdef CHARTS_FOR_QUICK2
                 Q_PROPERTY(QQmlListProperty<QObject> declarativeChildren READ declarativeChildren)
             #else
                 Q_PROPERTY(QDeclarativeListProperty<QObject> declarativeChildren READ declarativeChildren)
             #endif
                 Q_CLASSINFO("DefaultProperty", "declarativeChildren")
             public:
                 explicit DeclarativeLineSeries(QObject *parent = 0);
                 QXYSeries *xySeries() { return this; }
                 QAbstractAxis *axisX() { return m_axes->axisX(); }
                 void setAxisX(QAbstractAxis *axis) { m_axes->setAxisX(axis); }
                 QAbstractAxis *axisY() { return m_axes->axisY(); }
                 void setAxisY(QAbstractAxis *axis) { m_axes->setAxisY(axis); }
                 Q_REVISION(2) QAbstractAxis *axisXTop() { return m_axes->axisXTop(); }
                 Q_REVISION(2) void setAxisXTop(QAbstractAxis *axis) { m_axes->setAxisXTop(axis); }
                 Q_REVISION(2) QAbstractAxis *axisYRight() { return m_axes->axisYRight(); }
                 Q_REVISION(2) void setAxisYRight(QAbstractAxis *axis) { m_axes->setAxisYRight(axis); }
                 Q_REVISION(3) QAbstractAxis *axisAngular() { return m_axes->axisX(); }
                 Q_REVISION(3) void setAxisAngular(QAbstractAxis *axis) { m_axes->setAxisX(axis); }
                 Q_REVISION(3) QAbstractAxis *axisRadial() { return m_axes->axisY(); }
                 Q_REVISION(3) void setAxisRadial(QAbstractAxis *axis) { m_axes->setAxisY(axis); }
                 qreal width() const;
                 void setWidth(qreal width);
                 Qt::PenStyle style() const;
                 void setStyle(Qt::PenStyle style);
                 Qt::PenCapStyle capStyle() const;
                 void setCapStyle(Qt::PenCapStyle capStyle);
                 QDECLARATIVE_LIST_PROPERTY<QObject> declarativeChildren();
             public: // from QDeclarativeParserStatus
                 void classBegin() { DeclarativeXySeries::classBegin(); }
                 void componentComplete() { DeclarativeXySeries::componentComplete(); }
             public:
                 Q_INVOKABLE void append(qreal x, qreal y) { DeclarativeXySeries::append(x, y); }
                 Q_INVOKABLE void replace(qreal oldX, qreal oldY, qreal newX, qreal newY) { DeclarativeXySeries::replace(oldX, oldY, newX, newY); }
+                Q_REVISION(3) Q_INVOKABLE void replace(int index, qreal newX, qreal newY) { DeclarativeXySeries::replace(index, newX, newY); }
                 Q_INVOKABLE void remove(qreal x, qreal y) { DeclarativeXySeries::remove(x, y); }
+                Q_REVISION(3) Q_INVOKABLE void remove(int index) { DeclarativeXySeries::remove(index); }
                 Q_INVOKABLE void insert(int index, qreal x, qreal y) { DeclarativeXySeries::insert(index, x, y); }
                 Q_INVOKABLE void clear() { DeclarativeXySeries::clear(); }
                 Q_INVOKABLE QPointF at(int index) { return DeclarativeXySeries::at(index); }
             Q_SIGNALS:
                 void countChanged(int count);
                 Q_REVISION(1) void axisXChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void axisYChanged(QAbstractAxis *axis);
                 Q_REVISION(2) void axisXTopChanged(QAbstractAxis *axis);
                 Q_REVISION(2) void axisYRightChanged(QAbstractAxis *axis);
                 Q_REVISION(3) void axisAngularChanged(QAbstractAxis *axis);
                 Q_REVISION(3) void axisRadialChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void widthChanged(qreal width);
                 Q_REVISION(1) void styleChanged(Qt::PenStyle style);
                 Q_REVISION(1) void capStyleChanged(Qt::PenCapStyle capStyle);
             public Q_SLOTS:
                 static void appendDeclarativeChildren(QDECLARATIVE_LIST_PROPERTY<QObject> *list, QObject *element);
                 void handleCountChanged(int index);
             public:
                 DeclarativeAxes *m_axes;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVELINESERIES_H

plugins/declarative/declarativescatterseries.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 DECLARATIVESCATTERSERIES_H
             #define DECLARATIVESCATTERSERIES_H
             #include "qscatterseries.h"
             #include "declarativexyseries.h"
             #include "declarativeaxes.h"
             #include "shared_defines.h"
             #ifdef CHARTS_FOR_QUICK2
             #include <QtQml/QQmlListProperty>
             #include <QtQml/QQmlParserStatus>
             #else
             #include <QtDeclarative/QDeclarativeListProperty>
             #include <QtDeclarative/QDeclarativeParserStatus>
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeScatterSeries : public QScatterSeries, public DeclarativeXySeries, public QDECLARATIVE_PARSER_STATUS
             {
                 Q_OBJECT
             #ifdef CHARTS_FOR_QUICK2
                 Q_INTERFACES(QQmlParserStatus)
             #else
                 Q_INTERFACES(QDeclarativeParserStatus)
             #endif
                 Q_PROPERTY(int count READ count NOTIFY countChanged)
                 Q_PROPERTY(QAbstractAxis *axisX READ axisX WRITE setAxisX NOTIFY axisXChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY NOTIFY axisYChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisXTop READ axisXTop WRITE setAxisXTop NOTIFY axisXTopChanged REVISION 2)
                 Q_PROPERTY(QAbstractAxis *axisYRight READ axisYRight WRITE setAxisYRight NOTIFY axisYRightChanged REVISION 2)
                 Q_PROPERTY(QAbstractAxis *axisAngular READ axisAngular WRITE setAxisAngular NOTIFY axisAngularChanged REVISION 3)
                 Q_PROPERTY(QAbstractAxis *axisRadial READ axisRadial WRITE setAxisRadial NOTIFY axisRadialChanged REVISION 3)
                 Q_PROPERTY(qreal borderWidth READ borderWidth WRITE setBorderWidth NOTIFY borderWidthChanged REVISION 1)
             #ifdef CHARTS_FOR_QUICK2
                 Q_PROPERTY(QQmlListProperty<QObject> declarativeChildren READ declarativeChildren)
             #else
                 Q_PROPERTY(QDeclarativeListProperty<QObject> declarativeChildren READ declarativeChildren)
             #endif
                 Q_CLASSINFO("DefaultProperty", "declarativeChildren")
             public:
                 explicit DeclarativeScatterSeries(QObject *parent = 0);
                 QXYSeries *xySeries() { return this; }
                 QAbstractAxis *axisX() { return m_axes->axisX(); }
                 void setAxisX(QAbstractAxis *axis) { m_axes->setAxisX(axis); }
                 QAbstractAxis *axisY() { return m_axes->axisY(); }
                 void setAxisY(QAbstractAxis *axis) { m_axes->setAxisY(axis); }
                 Q_REVISION(2) QAbstractAxis *axisXTop() { return m_axes->axisXTop(); }
                 Q_REVISION(2) void setAxisXTop(QAbstractAxis *axis) { m_axes->setAxisXTop(axis); }
                 Q_REVISION(2) QAbstractAxis *axisYRight() { return m_axes->axisYRight(); }
                 Q_REVISION(2) void setAxisYRight(QAbstractAxis *axis) { m_axes->setAxisYRight(axis); }
                 Q_REVISION(3) QAbstractAxis *axisAngular() { return m_axes->axisX(); }
                 Q_REVISION(3) void setAxisAngular(QAbstractAxis *axis) { m_axes->setAxisX(axis); }
                 Q_REVISION(3) QAbstractAxis *axisRadial() { return m_axes->axisY(); }
                 Q_REVISION(3) void setAxisRadial(QAbstractAxis *axis) { m_axes->setAxisY(axis); }
                 qreal borderWidth() const;
                 void setBorderWidth(qreal borderWidth);
                 QDECLARATIVE_LIST_PROPERTY<QObject> declarativeChildren();
             public: // from QDeclarativeParserStatus
                 void classBegin() { DeclarativeXySeries::classBegin(); }
                 void componentComplete() { DeclarativeXySeries::componentComplete(); }
             public:
                 Q_INVOKABLE void append(qreal x, qreal y) { DeclarativeXySeries::append(x, y); }
                 Q_INVOKABLE void replace(qreal oldX, qreal oldY, qreal newX, qreal newY) { DeclarativeXySeries::replace(oldX, oldY, newX, newY); }
+                Q_REVISION(3) Q_INVOKABLE void replace(int index, qreal newX, qreal newY) { DeclarativeXySeries::replace(index, newX, newY); }
                 Q_INVOKABLE void remove(qreal x, qreal y) { DeclarativeXySeries::remove(x, y); }
+                Q_REVISION(3) Q_INVOKABLE void remove(int index) { DeclarativeXySeries::remove(index); }
                 Q_INVOKABLE void insert(int index, qreal x, qreal y) { DeclarativeXySeries::insert(index, x, y); }
                 Q_INVOKABLE void clear() { DeclarativeXySeries::clear(); }
                 Q_INVOKABLE QPointF at(int index) { return DeclarativeXySeries::at(index); }
             Q_SIGNALS:
                 void countChanged(int count);
                 Q_REVISION(1) void axisXChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void axisYChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void borderWidthChanged(qreal width);
                 Q_REVISION(2) void axisXTopChanged(QAbstractAxis *axis);
                 Q_REVISION(2) void axisYRightChanged(QAbstractAxis *axis);
                 Q_REVISION(3) void axisAngularChanged(QAbstractAxis *axis);
                 Q_REVISION(3) void axisRadialChanged(QAbstractAxis *axis);
             public Q_SLOTS:
                 static void appendDeclarativeChildren(QDECLARATIVE_LIST_PROPERTY<QObject> *list, QObject *element);
                 void handleCountChanged(int index);
             public:
                 DeclarativeAxes *m_axes;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVESCATTERSERIES_H

plugins/declarative/declarativesplineseries.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 DECLARATIVESPLINESERIES_H
             #define DECLARATIVESPLINESERIES_H
             #include "qsplineseries.h"
             #include "declarativexyseries.h"
             #include "declarativeaxes.h"
             #include "shared_defines.h"
             #ifdef CHARTS_FOR_QUICK2
             #include <QtQml/QQmlListProperty>
             #include <QtQml/QQmlParserStatus>
             #else
             #include <QtDeclarative/QDeclarativeListProperty>
             #include <QtDeclarative/QDeclarativeParserStatus>
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeSplineSeries : public QSplineSeries, public DeclarativeXySeries, public QDECLARATIVE_PARSER_STATUS
             {
                 Q_OBJECT
             #ifdef CHARTS_FOR_QUICK2
                 Q_INTERFACES(QQmlParserStatus)
             #else
                 Q_INTERFACES(QDeclarativeParserStatus)
             #endif
                 Q_PROPERTY(int count READ count NOTIFY countChanged)
                 Q_PROPERTY(QAbstractAxis *axisX READ axisX WRITE setAxisX NOTIFY axisXChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY NOTIFY axisYChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisXTop READ axisXTop WRITE setAxisXTop NOTIFY axisXTopChanged REVISION 2)
                 Q_PROPERTY(QAbstractAxis *axisYRight READ axisYRight WRITE setAxisYRight NOTIFY axisYRightChanged REVISION 2)
                 Q_PROPERTY(QAbstractAxis *axisAngular READ axisAngular WRITE setAxisAngular NOTIFY axisAngularChanged REVISION 3)
                 Q_PROPERTY(QAbstractAxis *axisRadial READ axisRadial WRITE setAxisRadial NOTIFY axisRadialChanged REVISION 3)
                 Q_PROPERTY(qreal width READ width WRITE setWidth NOTIFY widthChanged REVISION 1)
                 Q_PROPERTY(Qt::PenStyle style READ style WRITE setStyle NOTIFY styleChanged REVISION 1)
                 Q_PROPERTY(Qt::PenCapStyle capStyle READ capStyle WRITE setCapStyle NOTIFY capStyleChanged REVISION 1)
             #ifdef CHARTS_FOR_QUICK2
                 Q_PROPERTY(QQmlListProperty<QObject> declarativeChildren READ declarativeChildren)
             #else
                 Q_PROPERTY(QDeclarativeListProperty<QObject> declarativeChildren READ declarativeChildren)
             #endif
                 Q_CLASSINFO("DefaultProperty", "declarativeChildren")
             public:
                 explicit DeclarativeSplineSeries(QObject *parent = 0);
                 QXYSeries *xySeries() { return this; }
                 QAbstractAxis *axisX() { return m_axes->axisX(); }
                 void setAxisX(QAbstractAxis *axis) { m_axes->setAxisX(axis); }
                 QAbstractAxis *axisY() { return m_axes->axisY(); }
                 void setAxisY(QAbstractAxis *axis) { m_axes->setAxisY(axis); }
                 Q_REVISION(2) QAbstractAxis *axisXTop() { return m_axes->axisXTop(); }
                 Q_REVISION(2) void setAxisXTop(QAbstractAxis *axis) { m_axes->setAxisXTop(axis); }
                 Q_REVISION(2) QAbstractAxis *axisYRight() { return m_axes->axisYRight(); }
                 Q_REVISION(2) void setAxisYRight(QAbstractAxis *axis) { m_axes->setAxisYRight(axis); }
                 Q_REVISION(3) QAbstractAxis *axisAngular() { return m_axes->axisX(); }
                 Q_REVISION(3) void setAxisAngular(QAbstractAxis *axis) { m_axes->setAxisX(axis); }
                 Q_REVISION(3) QAbstractAxis *axisRadial() { return m_axes->axisY(); }
                 Q_REVISION(3) void setAxisRadial(QAbstractAxis *axis) { m_axes->setAxisY(axis); }
                 qreal width() const;
                 void setWidth(qreal width);
                 Qt::PenStyle style() const;
                 void setStyle(Qt::PenStyle style);
                 Qt::PenCapStyle capStyle() const;
                 void setCapStyle(Qt::PenCapStyle capStyle);
                 QDECLARATIVE_LIST_PROPERTY<QObject> declarativeChildren();
             public: // from QDeclarativeParserStatus
                 void classBegin() { DeclarativeXySeries::classBegin(); }
                 void componentComplete() { DeclarativeXySeries::componentComplete(); }
             public:
                 Q_INVOKABLE void append(qreal x, qreal y) { DeclarativeXySeries::append(x, y); }
                 Q_INVOKABLE void replace(qreal oldX, qreal oldY, qreal newX, qreal newY) { DeclarativeXySeries::replace(oldX, oldY, newX, newY); }
+                Q_REVISION(3) Q_INVOKABLE void replace(int index, qreal newX, qreal newY) { DeclarativeXySeries::replace(index, newX, newY); }
                 Q_INVOKABLE void remove(qreal x, qreal y) { DeclarativeXySeries::remove(x, y); }
+                Q_REVISION(3) Q_INVOKABLE void remove(int index) { DeclarativeXySeries::remove(index); }
                 Q_INVOKABLE void insert(int index, qreal x, qreal y) { DeclarativeXySeries::insert(index, x, y); }
                 Q_INVOKABLE void clear() { DeclarativeXySeries::clear(); }
                 Q_INVOKABLE QPointF at(int index) { return DeclarativeXySeries::at(index); }
             Q_SIGNALS:
                 void countChanged(int count);
                 Q_REVISION(1) void axisXChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void axisYChanged(QAbstractAxis *axis);
                 Q_REVISION(2) void axisXTopChanged(QAbstractAxis *axis);
                 Q_REVISION(2) void axisYRightChanged(QAbstractAxis *axis);
                 Q_REVISION(3) void axisAngularChanged(QAbstractAxis *axis);
                 Q_REVISION(3) void axisRadialChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void widthChanged(qreal width);
                 Q_REVISION(1) void styleChanged(Qt::PenStyle style);
                 Q_REVISION(1) void capStyleChanged(Qt::PenCapStyle capStyle);
             public Q_SLOTS:
                 static void appendDeclarativeChildren(QDECLARATIVE_LIST_PROPERTY<QObject> *list, QObject *element);
                 void handleCountChanged(int index);
             public:
                 DeclarativeAxes *m_axes;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVESPLINESERIES_H

plugins/declarative/declarativexyseries.cpp +14 0

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "declarativexyseries.h"
             #include "declarativexypoint.h"
             #include "qvxymodelmapper.h"
             #include "qhxymodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeXySeries::DeclarativeXySeries()
             {
             }
             DeclarativeXySeries::~DeclarativeXySeries()
             {
             }
             void DeclarativeXySeries::classBegin()
             {
             }
             void DeclarativeXySeries::componentComplete()
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 foreach (QObject *child, series->children()) {
                     if (qobject_cast<DeclarativeXYPoint *>(child)) {
                         DeclarativeXYPoint *point = qobject_cast<DeclarativeXYPoint *>(child);
                         series->append(point->x(), point->y());
                     } else if (qobject_cast<QVXYModelMapper *>(child)) {
                         QVXYModelMapper *mapper = qobject_cast<QVXYModelMapper *>(child);
                         mapper->setSeries(series);
                     } else if (qobject_cast<QHXYModelMapper *>(child)) {
                         QHXYModelMapper *mapper = qobject_cast<QHXYModelMapper *>(child);
                         mapper->setSeries(series);
                     }
                 }
             }
             void DeclarativeXySeries::append(qreal x, qreal y)
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 series->append(x, y);
             }
             void DeclarativeXySeries::replace(qreal oldX, qreal oldY, qreal newX, qreal newY)
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 series->replace(oldX, oldY, newX, newY);
             }
+            void DeclarativeXySeries::replace(int index, qreal newX, qreal newY)
+            {
+                QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
+                Q_ASSERT(series);
+                series->replace(index, newX, newY);
+            }
             void DeclarativeXySeries::remove(qreal x, qreal y)
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 series->remove(x, y);
             }
+            void DeclarativeXySeries::remove(int index)
+            {
+                QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
+                Q_ASSERT(series);
+                series->remove(index);
+            }
             void DeclarativeXySeries::insert(int index, qreal x, qreal y)
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 series->insert(index, QPointF(x, y));
             }
             void DeclarativeXySeries::clear()
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 series->clear();
             }
             QPointF DeclarativeXySeries::at(int index)
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(xySeries());
                 Q_ASSERT(series);
                 if (index >= 0 || index < series->count())
                     return series->points().at(index);
                 return QPointF(0, 0);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativexyseries.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 DECLARATIVE_XY_SERIES_H
             #define DECLARATIVE_XY_SERIES_H
             #include <QXYSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class QAbstractSeries;
             class DeclarativeXySeries
             {
             public:
                 explicit DeclarativeXySeries();
                 ~DeclarativeXySeries();
             public:
                 void classBegin();
                 void componentComplete();
                 virtual QXYSeries *xySeries() = 0;
                 void append(qreal x, qreal y);
                 void replace(qreal oldX, qreal oldY, qreal newX, qreal newY);
+                void replace(int index, qreal newX, qreal newY);
                 void remove(qreal x, qreal y);
+                void remove(int index);
                 void insert(int index, qreal x, qreal y);
                 void clear();
                 QPointF at(int index);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVE_XY_SERIES_H

src/xychart/qxyseries.cpp +17 0

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qxyseries.h"
             #include "qxyseries_p.h"
             #include "abstractdomain_p.h"
             #include "qvalueaxis.h"
             #include "xychart_p.h"
             #include "qxylegendmarker.h"
             #include "charthelpers_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                 \qmlclass XYSeries
                 \inherits AbstractSeries
                 The XYSeries class is a base class for line, spline and scatter series.
                 The class cannot be instantiated directly.
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisX
                 The x axis used for the series. If you leave both axisX and axisXTop undefined, a ValueAxis is created for
                 the series.
                 \sa axisXTop
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisY
                 The y axis used for the series. If you leave both axisY and axisYRight undefined, a ValueAxis is created for
                 the series.
                 \sa axisYRight
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisXTop
                 The x axis used for the series, drawn on top of the chart view. Note that you can only provide either axisX or
                 axisXTop, but not both.
                 \sa axisX
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisYRight
                 The y axis used for the series, drawn to the right on the chart view. Note that you can only provide either axisY
                 or axisYRight, but not both.
                 \sa axisY
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisAngular
                 The angular axis used for the series, drawn around the polar chart view.
                 \sa axisX
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisRadial
                 The radial axis used for the series, drawn inside the polar chart view.
                 \sa axisY
             */
             /*!
                 \property QXYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                 \qmlproperty bool XYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \property QXYSeries::color
                 The color of the series. This is line (pen) color in case of QLineSeries or QSplineSeries and
                 fill (brush) color in case of QScatterSeries or QAreaSeries.
                 \sa QXYSeries::pen(), QXYSeries::brush()
             */
             /*!
                 \qmlproperty color XYSeries::color
                 The color of the series. This is line (pen) color in case of LineSeries or SplineSeries and
                 fill (brush) color in case of ScatterSeries or AreaSeries.
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart.
             */
             /*!
                 \qmlsignal XYSeries::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on chart. For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onClicked: console.log("onClicked: " + point.x + ", " + point.y);
                 }
                 \endcode
             */
             /*!
                 \fn void QXYSeries::hovered(const QPointF &point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \qmlsignal XYSeries::onHovered(point point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \fn void QXYSeries::pointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
             */
             /*!
                 \fn void QXYSeries::pointsReplaced()
                 Signal is emitted when all points have been replaced with other points.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointsReplaced()
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal XYSeries::onPointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
                 \sa remove()
             */
             /*!
                 \qmlsignal XYSeries::onPointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
             */
             /*!
                 \fn void QXYSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \qmlsignal XYSeries::onColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \qmlmethod XYSeries::append(real x, real y)
                 Append point (\a x, \a y) to the series
             */
             /*!
                 \qmlmethod XYSeries::replace(real oldX, real oldY, real newX, real newY)
                 Replaces point (\a oldX, \a oldY) with point (\a newX, \a newY). Does nothing, if point (oldX, oldY) does not
                 exist.
             */
             /*!
                 \qmlmethod XYSeries::remove(real x, real y)
                 Removes point (\a x, \a y) from the series. Does nothing, if point (x, y) does not exist.
             */
             /*!
                 \qmlmethod XYSeries::insert(int index, real x, real y)
                 Inserts point (\a x, \a y) to the \a index. If index is 0 or smaller than 0 the point is prepended to the list of
                 points. If index is the same as or bigger than count, the point is appended to the list of points.
             */
             /*!
                 \qmlmethod QPointF XYSeries::at(int index)
                 Returns point at \a index. Returns (0, 0) if the index is not valid.
             */
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChart instance ownerships is transferred.
             */
             QXYSeries::QXYSeries(QXYSeriesPrivate &d, QObject *parent)
                 : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChart instances are owned by those,
                 and are destroyed when QChart instances are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point (\a x, \a y) to the series.
              */
             void QXYSeries::append(qreal x, qreal y)
             {
                 append(QPointF(x, y));
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series.
              */
             void QXYSeries::append(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(point)) {
                     d->m_points << point;
                     emit pointAdded(d->m_points.count() - 1);
                 }
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series.
              */
             void QXYSeries::append(const QList<QPointF> &points)
             {
                 foreach (const QPointF &point , points)
                     append(point);
             }
             /*!
               Replaces data point (\a oldX, \a oldY) with data point (\a newX, \a newY).
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(qreal oldX, qreal oldY, qreal newX, qreal newY)
             {
                 replace(QPointF(oldX, oldY), QPointF(newX, newY));
             }
             /*!
               Replaces \a oldPoint with \a newPoint.
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(const QPointF &oldPoint, const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(oldPoint);
                 if (index == -1)
                     return;
+                replace(index, newPoint);
+            }
+            void QXYSeries::replace(int index, qreal newX, qreal newY)
+            {
+                replace(index, QPointF(newX, newY));
+            }
+            void QXYSeries::replace(int index, const QPointF &newPoint)
+            {
+                Q_D(QXYSeries);
                 if (isValidValue(newPoint)) {
                     d->m_points[index] = newPoint;
                     emit pointReplaced(index);
                 }
             }
             /*!
               Replaces the current points with \a points.
               \note This is much faster than replacing data points one by one,
               or first clearing all data, and then appending the new data. Emits QXYSeries::pointsReplaced()
               when the points have been replaced.
               \sa QXYSeries::pointsReplaced()
             */
             void QXYSeries::replace(QList<QPointF> points)
             {
                 Q_D(QXYSeries);
                 d->m_points = points.toVector();
                 emit pointsReplaced();
             }
             /*!
               Removes the point (\a x, \a y) from the series.
             */
             void QXYSeries::remove(qreal x, qreal y)
             {
                 remove(QPointF(x, y));
             }
             /*!
               Removes the \a point from the series.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if (index == -1)
                     return;
+                remove(index);
+            }
+            void QXYSeries::remove(int index)
+            {
+                Q_D(QXYSeries);
                 d->m_points.remove(index);
                 emit pointRemoved(index);
             }
             /*!
                Inserts a \a point in the series at \a index position.
             */
             void QXYSeries::insert(int index, const QPointF &point)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(point)) {
                     d->m_points.insert(index, point);
                     emit pointAdded(index);
                 }
             }
             /*!
                 Removes all points from the series.
             */
             void QXYSeries::clear()
             {
                 Q_D(QXYSeries);
                 for (int i = d->m_points.size() - 1; i >= 0; i--)
                     remove(d->m_points.at(i));
             }
             /*!
                 Returns list of points in the series.
             */
             QList<QPointF> QXYSeries::points() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.toList();
             }
             /*!
                 Returns point at \a index in internal points vector.
             */
             const QPointF &QXYSeries::at(int index) const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.at(index);
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.count();
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen != pen) {
                     bool emitColorChanged = d->m_pen.color() != pen.color();
                     d->m_pen = pen;
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(pen.color());
                 }
             }
             QPen QXYSeries::pen() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QXYSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QXYSeries::brush() const
             {
                 Q_D(const QXYSeries);
                 return d->m_brush;
             }
             void QXYSeries::setColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QXYSeries::color() const
             {
                 return pen().color();
             }
             void QXYSeries::setPointsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             bool QXYSeries::pointsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointsVisible;
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa append()
             */
             QXYSeries &QXYSeries::operator<< (const QPointF &point)
             {
                 append(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa append()
             */
             QXYSeries &QXYSeries::operator<< (const QList<QPointF>& points)
             {
                 append(points);
                 return *this;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q)
                 : QAbstractSeriesPrivate(q),
                   m_pointsVisible(false)
             {
             }
             void QXYSeriesPrivate::initializeDomain()
             {
                 qreal minX(0);
                 qreal minY(0);
                 qreal maxX(1);
                 qreal maxY(1);
                 Q_Q(QXYSeries);
                 const QList<QPointF>& points = q->points();
                 if (!points.isEmpty()) {
                     minX = points[0].x();
                     minY = points[0].y();
                     maxX = minX;
                     maxY = minY;
                     for (int i = 0; i < points.count(); i++) {
                         qreal x = points[i].x();
                         qreal y = points[i].y();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                     }
                 }
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             QList<QLegendMarker*> QXYSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<QLegendMarker*> list;
                 return list << new QXYLegendMarker(q,legend);
             }
             void QXYSeriesPrivate::initializeAxes()
             {
             }
             QAbstractAxis::AxisType QXYSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValue;
             }
             QAbstractAxis* QXYSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return 0;
             }
             void QXYSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
             {
                 XYChart *item = static_cast<XYChart *>(m_item.data());
                 Q_ASSERT(item);
                 if (options.testFlag(QChart::SeriesAnimations)) {
                     item->setAnimation(new XYAnimation(item));
                 }else{
                     item->setAnimation(0);
                 }
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.h +3 0

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 QXYSERIES_H
             #define QXYSERIES_H
             #include <qchartglobal.h>
             #include <qabstractseries.h>
             #include <QPen>
             #include <QBrush>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYSeriesPrivate;
             class QXYModelMapper;
             class QTCOMMERCIALCHART_EXPORT QXYSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(bool pointsVisible READ pointsVisible WRITE setPointsVisible)
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
             protected:
                 explicit QXYSeries(QXYSeriesPrivate &d, QObject *parent = 0);
             public:
                 ~QXYSeries();
                 void append(qreal x, qreal y);
                 void append(const QPointF &point);
                 void append(const QList<QPointF> &points);
                 void replace(qreal oldX, qreal oldY, qreal newX, qreal newY);
                 void replace(const QPointF &oldPoint, const QPointF &newPoint);
+                void replace(int index, qreal newX, qreal newY);
+                void replace(int index, const QPointF &newPoint);
                 void remove(qreal x, qreal y);
                 void remove(const QPointF &point);
+                void remove(int index);
                 void insert(int index, const QPointF &point);
                 void clear();
                 int count() const;
                 QList<QPointF> points() const;
                 const QPointF &at(int index) const;
                 QXYSeries &operator << (const QPointF &point);
                 QXYSeries &operator << (const QList<QPointF> &points);
                 virtual void setPen(const QPen &pen);
                 QPen pen() const;
                 virtual void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 virtual void setColor(const QColor &color);
                 virtual QColor color() const;
                 void setPointsVisible(bool visible = true);
                 bool pointsVisible() const;
                 void replace(QList<QPointF> points);
             Q_SIGNALS:
                 void clicked(const QPointF &point);
                 void hovered(const QPointF &point, bool state);
                 void pointReplaced(int index);
                 void pointRemoved(int index);
                 void pointAdded(int index);
                 void colorChanged(QColor color);
                 void pointsReplaced();
             private:
                 Q_DECLARE_PRIVATE(QXYSeries)
                 Q_DISABLE_COPY(QXYSeries)
                 friend class QXYLegendMarkerPrivate;
                 friend class XYLegendMarker;
                 friend class XYChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QXYSERIES_H

tests/auto/qxyseries/tst_qxyseries.cpp +23 0

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "tst_qxyseries.h"
             Q_DECLARE_METATYPE(QList<QPointF>)
             void tst_QXYSeries::initTestCase()
             {
             }
             void tst_QXYSeries::cleanupTestCase()
             {
             }
             void tst_QXYSeries::init()
             {
                 m_view = new QChartView(newQChartOrQPolarChart());
                 m_chart = m_view->chart();
             }
             void tst_QXYSeries::cleanup()
             {
                 delete m_view;
                 m_view = 0;
                 m_chart = 0;
                 m_series = 0;
             }
             void tst_QXYSeries::seriesName()
             {
                 QSignalSpy nameSpy(m_series, SIGNAL(nameChanged()));
                 QCOMPARE(m_series->name(), QString());
                 m_series->setName("seriesname");
                 QCOMPARE(m_series->name(), QString("seriesname"));
                 TRY_COMPARE(nameSpy.count(), 1);
             }
             void tst_QXYSeries::seriesVisible()
             {
                 QSignalSpy visibleSpy(m_series, SIGNAL(visibleChanged()));
                 QCOMPARE(m_series->isVisible(), true);
                 m_series->setVisible(false);
                 QCOMPARE(m_series->isVisible(), false);
                 m_series->setVisible(true);
                 TRY_COMPARE(visibleSpy.count(), 2);
             }
             void tst_QXYSeries::seriesOpacity()
             {
                 QSignalSpy opacitySpy(m_series, SIGNAL(opacityChanged()));
                 QCOMPARE(m_series->opacity(), 1.0);
                 m_series->setOpacity(0.5);
                 QCOMPARE(m_series->opacity(), 0.5);
                 QCOMPARE(opacitySpy.count(), 1);
                 m_series->setOpacity(0.0);
                 QCOMPARE(m_series->opacity(), 0.0);
                 QCOMPARE(opacitySpy.count(), 2);
                 m_series->setOpacity(1.0);
                 QCOMPARE(m_series->opacity(), 1.0);
                 QCOMPARE(opacitySpy.count(), 3);
             }
             void tst_QXYSeries::append_data()
             {
                 QTest::addColumn< QList<QPointF> >("points");
                 QTest::addColumn< QList<QPointF> >("otherPoints");
                 QTest::newRow("0,0 1,1 2,2 3,3")
                         << (QList<QPointF>() << QPointF(0,0) << QPointF(1,1) << QPointF(2,2) << QPointF(3,3))
                         << (QList<QPointF>() << QPointF(4,4) << QPointF(5,5) << QPointF(6,6) << QPointF(7,7));
                 QTest::newRow("0,0 -1,-1 -2,-2 -3,-3")
                         << (QList<QPointF>() << QPointF(0,0) << QPointF(-1,-1) << QPointF(-2,-2) << QPointF(-3,-3))
                         << (QList<QPointF>() << QPointF(-4,-4) << QPointF(-5,-5) << QPointF(-6,-6) << QPointF(-7,-7));
             }
             void tst_QXYSeries::append_raw_data()
             {
                 append_data();
             }
             void tst_QXYSeries::append_raw()
             {
                 QFETCH(QList<QPointF>, points);
                 QFETCH(QList<QPointF>, otherPoints);
                 QSignalSpy spy0(m_series, SIGNAL(clicked(QPointF)));
                 QSignalSpy addedSpy(m_series, SIGNAL(pointAdded(int)));
                 m_series->append(points);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(addedSpy.count(), points.count());
                 QCOMPARE(m_series->points(), points);
                 // Process events between appends
                 foreach (const QPointF &point, otherPoints) {
                     m_series->append(point);
                     QApplication::processEvents();
                 }
             }
             void tst_QXYSeries::chart_append_data()
             {
                 append_data();
             }
             void tst_QXYSeries::chart_append()
             {
                 append_raw();
                 m_chart->addSeries(m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QXYSeries::append_chart_data()
             {
                 append_data();
             }
             void tst_QXYSeries::append_chart()
             {
                 m_view->show();
                 m_chart->addSeries(m_series);
                 QTest::qWaitForWindowShown(m_view);
                 append_raw();
             }
             void tst_QXYSeries::append_chart_animation_data()
             {
                 append_data();
             }
             void tst_QXYSeries::append_chart_animation()
             {
                 m_chart->setAnimationOptions(QChart::AllAnimations);
                 append_chart();
             }
             void tst_QXYSeries::count_data()
             {
                 QTest::addColumn<int>("count");
                 QTest::newRow("0") << 0;
                 QTest::newRow("5") << 5;
                 QTest::newRow("10") << 5;
             }
             void tst_QXYSeries::count_raw_data()
             {
                 count_data();
             }
             void tst_QXYSeries::count_raw()
             {
                 QFETCH(int, count);
                 QSignalSpy spy0(m_series, SIGNAL(clicked(QPointF)));
                 for(int i=0 ; i< count; ++i)
                     m_series->append(i,i);
                 TRY_COMPARE(spy0.count(), 0);
                 QCOMPARE(m_series->count(), count);
             }
             void tst_QXYSeries::remove_raw_data()
             {
                 append_data();
             }
             void tst_QXYSeries::remove_raw()
             {
                 QFETCH(QList<QPointF>, points);
                 QSignalSpy spy0(m_series, SIGNAL(clicked(QPointF)));
                 m_series->append(points);
                 TRY_COMPARE(spy0.count(), 0);
                 QCOMPARE(m_series->points(), points);
                 foreach (const QPointF& point,points)
                     m_series->remove(point);
                 QCOMPARE(m_series->points().count(), 0);
                 TRY_COMPARE(spy0.count(), 0);
                 m_series->append(points);
                 QCOMPARE(m_series->points(), points);
                 //reverse order
                 for(int i = points.count()-1 ; i>=0; i--){
                     m_series->remove(points[i]);
                 }
                 QCOMPARE(m_series->points().count(), 0);
                 QApplication::processEvents();
                 // Process events between removes
                 m_series->append(points);
                 QCOMPARE(m_series->points(), points);
                 foreach (const QPointF &point, points) {
                     m_series->remove(point);
                     QApplication::processEvents();
                 }
                 // Actual meaningful delay between removes, but still shorter than animation duration
                 // (simulate e.g. spamming a hypothetical "remove last point"-button)
                 QList<QPointF> bunchOfPoints;
                 for (int i = 0; i < 10; i++)
                     bunchOfPoints.append(QPointF(i, (qreal) rand() / (qreal) RAND_MAX));
                 m_series->replace(bunchOfPoints);
                 QCOMPARE(m_series->points(), bunchOfPoints);
                 QTest::qWait(1500); // Wait for append animations to be over
                 for (int i = bunchOfPoints.count() - 1; i >= 0; i--) {
                     m_series->remove(bunchOfPoints.at(i));
                     QTest::qWait(50);
                 }
+                QCOMPARE(m_series->points().count(), 0);
+                // Removal using index
+                for (int i = 0; i < 10; i++)
+                    bunchOfPoints.append(QPointF(i, (qreal) rand() / (qreal) RAND_MAX));
+                m_series->replace(bunchOfPoints);
+                m_series->remove(5);
+                m_series->remove(0);
+                QCOMPARE(m_series->points().count(), (bunchOfPoints.count() - 2));
+                for (int i = bunchOfPoints.count() - 3; i >= 0; i--) {
+                    m_series->remove(i);
+                    QCOMPARE(m_series->points().count(), i);
+                }
+                QCOMPARE(m_series->points().count(), 0);
             }
             void tst_QXYSeries::remove_chart_data()
             {
                 append_data();
             }
             void tst_QXYSeries::remove_chart()
             {
                 m_view->show();
                 m_chart->addSeries(m_series);
                 QTest::qWaitForWindowShown(m_view);
                 remove_raw();
             }
             void tst_QXYSeries::remove_chart_animation_data()
             {
                 append_data();
             }
             void tst_QXYSeries::remove_chart_animation()
             {
                 m_chart->setAnimationOptions(QChart::AllAnimations);
                 remove_chart();
             }
             void tst_QXYSeries::clear_raw_data()
             {
                 append_data();
             }
             void tst_QXYSeries::clear_raw()
             {
                 QFETCH(QList<QPointF>, points);
                 QSignalSpy spy0(m_series, SIGNAL(clicked(QPointF)));
                 m_series->append(points);
                 TRY_COMPARE(spy0.count(), 0);
                 QCOMPARE(m_series->points(), points);
                 m_series->clear();
                 TRY_COMPARE(spy0.count(), 0);
                 QCOMPARE(m_series->points().count(), 0);
                 QApplication::processEvents();
             }
             void tst_QXYSeries::clear_chart_data()
             {
                 append_data();
             }
             void tst_QXYSeries::clear_chart()
             {
                 m_view->show();
                 m_chart->addSeries(m_series);
                 QTest::qWaitForWindowShown(m_view);
                 clear_raw();
             }
             void tst_QXYSeries::clear_chart_animation_data()
             {
                 append_data();
             }
             void tst_QXYSeries::clear_chart_animation()
             {
                 m_chart->setAnimationOptions(QChart::AllAnimations);
                 clear_chart();
             }
             void tst_QXYSeries::replace_raw_data()
             {
                 append_data();
             }
             void tst_QXYSeries::replace_raw()
             {
                 QFETCH(QList<QPointF>, points);
                 QFETCH(QList<QPointF>, otherPoints);
                 QSignalSpy pointReplacedSpy(m_series, SIGNAL(pointReplaced(int)));
                 QSignalSpy pointsReplacedSpy(m_series, SIGNAL(pointsReplaced()));
                 m_series->append(points);
                 TRY_COMPARE(pointReplacedSpy.count(), 0);
                 TRY_COMPARE(pointsReplacedSpy.count(), 0);
                 QCOMPARE(m_series->points(), points);
                 foreach (const QPointF& point, points)
                    m_series->replace(point.x(),point.y(),point.x(),0);
                 TRY_COMPARE(pointReplacedSpy.count(), points.count());
                 TRY_COMPARE(pointsReplacedSpy.count(), 0);
                 // Replace a point that does not exist
                 m_series->replace(-123, 999, 0, 0);
                 TRY_COMPARE(pointReplacedSpy.count(), points.count());
                 TRY_COMPARE(pointsReplacedSpy.count(), 0);
                 QList<QPointF> newPoints = m_series->points();
                 QCOMPARE(newPoints.count(), points.count());
                 for(int i =0 ; i<points.count() ; ++i) {
                     QCOMPARE(points[i].x(), newPoints[i].x());
                     QCOMPARE(newPoints[i].y(), 0.0);
                 }
                 // Replace all points
                 QList<QPointF> allPoints;
                 for (int i = 0; i < 10; i++)
                     allPoints.append(QPointF(i, (qreal) rand() / (qreal) RAND_MAX));
                 m_series->replace(allPoints);
                 TRY_COMPARE(pointReplacedSpy.count(), points.count());
                 TRY_COMPARE(pointsReplacedSpy.count(), 1);
                 m_series->replace(points);
                 QApplication::processEvents();
                 // Process events between replaces
                 for (int i = 0; i < points.count(); ++i) {
                     m_series->replace(points.at(i), otherPoints.at(i));
                     QApplication::processEvents();
                 }
                 newPoints = m_series->points();
                 QCOMPARE(newPoints.count(), points.count());
                 for (int i = 0; i < points.count(); ++i) {
                     QCOMPARE(otherPoints.at(i).x(), newPoints.at(i).x());
                     QCOMPARE(otherPoints.at(i).y(), newPoints.at(i).y());
                 }
                 // Append followed by a replace shouldn't crash
                 m_series->clear();
                 m_series->append(QPointF(22,22));
                 m_series->append(QPointF(23,23));
                 QApplication::processEvents();
                 m_series->replace(QPointF(23,23), otherPoints.at(1));
                 QCOMPARE(m_series->points().at(1).x(), otherPoints.at(1).x());
                 QCOMPARE(m_series->points().at(1).y(), otherPoints.at(1).y());
+                // Replace using index
+                m_series->append(otherPoints);
+                m_series->replace(0, QPointF(333, 333));
+                m_series->replace(3, 444, 444);
+                m_series->replace(m_series->count() - 1, QPointF(555, 555));
+                QCOMPARE(m_series->points().at(0),  QPointF(333, 333));
+                QCOMPARE(m_series->points().at(3), QPointF(444, 444));
+                QCOMPARE(m_series->points().at(m_series->count() - 1), QPointF(555, 555));
             }
             void tst_QXYSeries::replace_chart_data()
             {
                 append_data();
             }
             void tst_QXYSeries::replace_chart()
             {
                 m_view->show();
                 m_chart->addSeries(m_series);
                 QTest::qWaitForWindowShown(m_view);
                 replace_raw();
             }
             void tst_QXYSeries::replace_chart_animation_data()
             {
                 append_data();
             }
             void tst_QXYSeries::replace_chart_animation()
             {
                 m_chart->setAnimationOptions(QChart::AllAnimations);
                 replace_chart();
             }
             void tst_QXYSeries::insert_data()
             {
                 append_data();
             }
             void tst_QXYSeries::insert()
             {
                 QFETCH(QList<QPointF>, points);
                 m_series->append(points);
                 QSignalSpy addedSpy(m_series, SIGNAL(pointAdded(int)));
                 m_series->insert(0, QPointF(5, 5));
                 TRY_COMPARE(addedSpy.count(), 1);
                 QCOMPARE(m_series->points().count(), points.count() + 1);
                 m_series->insert(m_series->count(), QPointF(6, 6));
                 TRY_COMPARE(addedSpy.count(), 2);
                 QCOMPARE(m_series->points().count(), points.count() + 2);
             }
             void tst_QXYSeries::oper_data()
             {
                 append_data();
             }
             void tst_QXYSeries::oper()
             {
                 QFETCH(QList<QPointF>, points);
                 QSignalSpy spy0(m_series, SIGNAL(clicked(QPointF)));
                 foreach (const QPointF& point,points)
                 {
                     *m_series<<point;
                 }
                 QCOMPARE(m_series->points(), points);
                 TRY_COMPARE(spy0.count(), 0);
             }
             void tst_QXYSeries::pen_data()
             {
                 QTest::addColumn<QPen>("pen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("black") << QPen(Qt::black);
                 QTest::newRow("red") << QPen(Qt::red);
             }
             void tst_QXYSeries::pen()
             {
                 QFETCH(QPen, pen);
                 QSignalSpy spy0(m_series, SIGNAL(clicked(QPointF)));
                 m_series->setPen(pen);
                 TRY_COMPARE(spy0.count(), 0);
                 QCOMPARE(m_series->pen(), pen);
                 m_chart->addSeries(m_series);
                 if (pen != QPen())
                     QCOMPARE(m_series->pen(), pen);
                 m_chart->setTheme(QChart::ChartThemeDark);
                 // setting a theme will overwrite all customizations
                 if (pen != QPen())
                     QVERIFY(m_series->pen() != pen);
             }
             void tst_QXYSeries::pointsVisible_data()
             {
                 QTest::addColumn<bool>("pointsVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QXYSeries::pointsVisible_raw_data()
             {
                 pointsVisible_data();
             }
             void tst_QXYSeries::pointsVisible_raw()
             {
                 QFETCH(bool, pointsVisible);
                 QSignalSpy spy0(m_series, SIGNAL(clicked(QPointF)));
                 m_series->setPointsVisible(pointsVisible);
                 TRY_COMPARE(spy0.count(), 0);
                 QCOMPARE(m_series->pointsVisible(), pointsVisible);
             }
             void tst_QXYSeries::changedSignals()
             {
                 QSignalSpy visibleSpy(m_series, SIGNAL(visibleChanged()));
                 QSignalSpy nameSpy(m_series, SIGNAL(nameChanged()));
                 QSignalSpy colorSpy(m_series, SIGNAL(colorChanged(QColor)));
                 // Visibility
                 m_series->setVisible(false);
                 m_series->setVisible(false);
                 TRY_COMPARE(visibleSpy.count(), 1);
                 m_series->setVisible(true);
                 TRY_COMPARE(visibleSpy.count(), 2);
                 // Color
                 m_series->setColor(QColor("aliceblue"));
                 TRY_COMPARE(colorSpy.count(), 1);
                 // Pen and Brush
                 QPen p = m_series->pen();
                 p.setColor("aquamarine");
                 m_series->setPen(p);
                 QBrush b = m_series->brush();
                 b.setColor("beige");
                 m_series->setBrush(b);
                 TRY_COMPARE(colorSpy.count(), 2);
                 // Verify all the signals again, to make sure no extra signals were emitted
                 TRY_COMPARE(visibleSpy.count(), 2);
                 TRY_COMPARE(nameSpy.count(), 0);
                 TRY_COMPARE(colorSpy.count(), 2);
             }

tests/qmlchartproperties/qml/qmlchartproperties/LineEditor.qml +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series
                 Button {
                     text: "visible"
                     onClicked: series.visible = !series.visible;
                 }
                 Button {
                     text: "opacity +"
                     onClicked: series.opacity += 0.1;
                 }
                 Button {
                     text: "opacity -"
                     onClicked: series.opacity -= 0.1;
                 }
                 Button {
                     text: "color"
                     onClicked: series.color = main.nextColor();
                 }
                 Button {
                     text: series != undefined ? "width + (" + series.width + ")" : ""
                     onClicked: series.width += 0.5;
                 }
                 Button {
                     text: series != undefined ? "width - (" + series.width + ")" : ""
                     onClicked: series.width -= 0.5;
                 }
                 Button {
                     text: series != undefined ? "style + (" + series.style + ")" : ""
                     onClicked: series.style++;
                 }
                 Button {
                     text: series != undefined ? "style - (" + series.style + ")" : ""
                     onClicked: series.style--;
                 }
                 Button {
                     text: series != undefined ? "cap style + (" + series.capStyle + ")" : ""
                     onClicked: series.capStyle++;
                 }
                 Button {
                     text: series != undefined ? "cap style - (" +series.capStyle + ")" : ""
                     onClicked: series.capStyle--;
                 }
                 Button {
                     text: "points visible"
                     onClicked: series.pointsVisible = !series.pointsVisible;
                 }
                 Button {
                     text: "append point"
                     onClicked: series.append(series.count - 1, series.count - 1);
                 }
                 Button {
                     text: "replace point"
                     onClicked: {
                         var xyPoint = series.at(series.count - 1);
-                        series.replace(xyPoint.x, xyPoint.y, xyPoint.x, xyPoint.y + 0.1);
+                        series.replace(series.count - 1, xyPoint.x, xyPoint.y + 0.1);
                     }
                 }
                 Button {
                     text: "remove point"
-                    onClicked: series.remove(series.at(series.count - 1).x, series.at(series.count - 1).y);
+                    onClicked: series.remove(series.count - 1);
                 }
                 Button {
                     text: "insert point"
                     onClicked: series.insert(series.count - 2, series.count - 2, series.count - 2);
                 }
                 Button {
                     text: "clear"
                     onClicked: series.clear();
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/ScatterEditor.qml +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series
                 Button {
                     text: "visible"
                     onClicked: series.visible = !series.visible;
                 }
                 Button {
                     text: "opacity +"
                     onClicked: series.opacity += 0.1;
                 }
                 Button {
                     text: "opacity -"
                     onClicked: series.opacity -= 0.1;
                 }
                 Button {
                     text: "color"
                     onClicked: series.color = main.nextColor();
                 }
                 Button {
                     text: "borderColor"
                     onClicked: series.borderColor = main.nextColor();
                 }
                 Button {
                     text: series != undefined ? "borderWidth + (" + series.borderWidth + ")" : ""
                     onClicked: series.borderWidth += 0.5;
                 }
                 Button {
                     text: series != undefined ? "borderWidth - (" + series.borderWidth + ")" : ""
                     onClicked: series.borderWidth -= 0.5;
                 }
                 Button {
                     text: "markerSize +"
                     onClicked: series.markerSize += 1.0;
                 }
                 Button {
                     text: "markerSize -"
                     onClicked: series.markerSize -= 1.0;
                 }
                 Button {
                     text: "markerShape"
                     onClicked: series.markerShape = ((series.markerShape + 1) % 2);
                 }
                 Button {
                     text: "append point"
                     onClicked: series.append(series.count - 1, series.count - 1);
                 }
                 Button {
                     text: "replace point"
                     onClicked: {
                         var xyPoint = series.at(series.count - 1);
-                        series.replace(xyPoint.x, xyPoint.y, xyPoint.x, xyPoint.y + 0.1);
+                        series.replace(series.count - 1, xyPoint.x, xyPoint.y + 0.1);
                     }
                 }
                 Button {
                     text: "remove point"
-                    onClicked: series.remove(series.at(series.count - 1).x, series.at(series.count - 1).y);
+                    onClicked: series.remove(series.count - 1);
                 }
                 Button {
                     text: "insert point"
                     onClicked: series.insert(series.count - 2, series.count - 2, series.count - 2);
                 }
                 Button {
                     text: "clear"
                     onClicked: series.clear();
                 }
             }

tests/quick2chartproperties/qml/quick2chartproperties/LineEditor.qml +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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$
             **
             ****************************************************************************/
             import QtQuick 2.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series
                 Button {
                     text: "visible"
                     onClicked: series.visible = !series.visible;
                 }
                 Button {
                     text: "opacity +"
                     onClicked: series.opacity += 0.1;
                 }
                 Button {
                     text: "opacity -"
                     onClicked: series.opacity -= 0.1;
                 }
                 Button {
                     text: "color"
                     onClicked: series.color = main.nextColor();
                 }
                 Button {
                     text: series != undefined ? "width + (" + series.width + ")" : ""
                     onClicked: series.width += 0.5;
                 }
                 Button {
                     text: series != undefined ? "width - (" + series.width + ")" : ""
                     onClicked: series.width -= 0.5;
                 }
                 Button {
                     text: series != undefined ? "style + (" + series.style + ")" : ""
                     onClicked: series.style++;
                 }
                 Button {
                     text: series != undefined ? "style - (" + series.style + ")" : ""
                     onClicked: series.style--;
                 }
                 Button {
                     text: series != undefined ? "cap style + (" + series.capStyle + ")" : ""
                     onClicked: series.capStyle++;
                 }
                 Button {
                     text: series != undefined ? "cap style - (" +series.capStyle + ")" : ""
                     onClicked: series.capStyle--;
                 }
                 Button {
                     text: "points visible"
                     onClicked: series.pointsVisible = !series.pointsVisible;
                 }
                 Button {
                     text: "append point"
                     onClicked: series.append(series.count - 1, series.count - 1);
                 }
                 Button {
                     text: "replace point"
                     onClicked: {
                         var xyPoint = series.at(series.count - 1);
-                        series.replace(xyPoint.x, xyPoint.y, xyPoint.x, xyPoint.y + 0.1);
+                        series.replace(series.count - 1, xyPoint.x, xyPoint.y + 0.1);
                     }
                 }
                 Button {
                     text: "remove point"
-                    onClicked: series.remove(series.at(series.count - 1).x, series.at(series.count - 1).y);
+                    onClicked: series.remove(series.count - 1);
                 }
                 Button {
                     text: "insert point"
                     onClicked: series.insert(series.count - 2, series.count - 2, series.count - 2);
                 }
                 Button {
                     text: "clear"
                     onClicked: series.clear();
                 }
             }

tests/quick2chartproperties/qml/quick2chartproperties/ScatterEditor.qml +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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$
             **
             ****************************************************************************/
             import QtQuick 2.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series
                 Button {
                     text: "visible"
                     onClicked: series.visible = !series.visible;
                 }
                 Button {
                     text: "opacity +"
                     onClicked: series.opacity += 0.1;
                 }
                 Button {
                     text: "opacity -"
                     onClicked: series.opacity -= 0.1;
                 }
                 Button {
                     text: "color"
                     onClicked: series.color = main.nextColor();
                 }
                 Button {
                     text: "borderColor"
                     onClicked: series.borderColor = main.nextColor();
                 }
                 Button {
                     text: series != undefined ? "borderWidth + (" + series.borderWidth + ")" : ""
                     onClicked: series.borderWidth += 0.5;
                 }
                 Button {
                     text: series != undefined ? "borderWidth - (" + series.borderWidth + ")" : ""
                     onClicked: series.borderWidth -= 0.5;
                 }
                 Button {
                     text: "markerSize +"
                     onClicked: series.markerSize += 1.0;
                 }
                 Button {
                     text: "markerSize -"
                     onClicked: series.markerSize -= 1.0;
                 }
                 Button {
                     text: "markerShape"
                     onClicked: series.markerShape = ((series.markerShape + 1) % 2);
                 }
                 Button {
                     text: "append point"
                     onClicked: series.append(series.count - 1, series.count - 1);
                 }
                 Button {
                     text: "replace point"
                     onClicked: {
                         var xyPoint = series.at(series.count - 1);
-                        series.replace(xyPoint.x, xyPoint.y, xyPoint.x, xyPoint.y + 0.1);
+                        series.replace(series.count - 1, xyPoint.x, xyPoint.y + 0.1);
                     }
                 }
                 Button {
                     text: "remove point"
-                    onClicked: series.remove(series.at(series.count - 1).x, series.at(series.count - 1).y);
+                    onClicked: series.remove(series.count - 1);
                 }
                 Button {
                     text: "insert point"
                     onClicked: series.insert(series.count - 2, series.count - 2, series.count - 2);
                 }
                 Button {
                     text: "clear"
                     onClicked: series.clear();
                 }
             }

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