HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1783:86f3ac473a35

Added a new QXYSeries::replace override for performance reasons....

Tero Ahola -

r1783:86f3ac473a35

parent child

Context file:

r1783:86f3ac473a35

Collapse all files

demos/qmloscilloscope/datasource.cpp created 644 +55 0

@@ -0,0 +1,55
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "datasource.h"
	22	#include <QXYSeries>
	23	#include <QDebug>
	24
	25	QTCOMMERCIALCHART_USE_NAMESPACE
	26
	27	DataSource::DataSource(QObject *parent) :
	28	QObject(parent),
	29	m_index(0)
	30	{
	31	const int rowCount = 5;
	32	const int colCount = 1024;
	33
	34	for (int i(0); i < rowCount; i++) {
	35	QList<QPointF> points;
	36	for (int j(0); j < colCount; j++) {
	37	qreal x = j;
	38	qreal y = sin(3.14159265358979 / 50 * x) + 0.5 + (qreal) rand() / (qreal) RAND_MAX;
	39	points.append(QPointF(x, y));
	40	}
	41	m_data.append(points);
	42	}
	43	}
	44
	45	void DataSource::update(QAbstractSeries *series)
	46	{
	47	QXYSeries xySeries = qobject_cast<QXYSeries >(series);
	48	Q_ASSERT(xySeries);
	49
	50	QList<QPointF> points = m_data.at(m_index);
	51	//xySeries->clear();
	52	//xySeries->append(points);
	53	xySeries->replace(points);
	54	m_index = (m_index + 1) % m_data.count();
	55	}

demos/qmloscilloscope/datasource.h created 644 +45 0

@@ -0,0 +1,45
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#ifndef DATASOURCE_H
	22	#define DATASOURCE_H
	23
	24	#include <QObject>
	25	#include <QAbstractSeries>
	26
	27	QTCOMMERCIALCHART_USE_NAMESPACE
	28
	29	class DataSource : public QObject
	30	{
	31	Q_OBJECT
	32	public:
	33	explicit DataSource(QObject *parent = 0);
	34
	35	signals:
	36
	37	public slots:
	38	void update(QAbstractSeries *series);
	39
	40	private:
	41	QList<QList<QPointF> > m_data;
	42	int m_index;
	43	};
	44
	45	#endif // DATASOURCE_H

demos/qmloscilloscope/main.cpp created 644 +42 0

@@ -0,0 +1,42
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include <QtGui/QApplication>
	22	#include <QDeclarativeEngine>
	23	#include <QDeclarativeContext>
	24	#include <QGLWidget>
	25	#include "qmlapplicationviewer.h"
	26	#include "datasource.h"
	27
	28	Q_DECL_EXPORT int main(int argc, char *argv[])
	29	{
	30	QScopedPointer<QApplication> app(createApplication(argc, argv));
	31	QScopedPointer<QmlApplicationViewer> viewer(QmlApplicationViewer::create());
	32
	33	DataSource dataSource;
	34	viewer->rootContext()->setContextProperty("dataSource", &dataSource);
	35
	36	viewer->setOrientation(QmlApplicationViewer::ScreenOrientationAuto);
	37	viewer->setSource(QUrl("qrc:/qml/qmloscilloscope/main.qml"));
	38	viewer->setViewport(new QGLWidget());
	39	viewer->showExpanded();
	40
	41	return app->exec();
	42	}

demos/qmloscilloscope/qml/qmloscilloscope/main.qml created 644 +72 0

@@ -0,0 +1,72
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	import QtQuick 1.0
	22	import QtCommercial.Chart 1.0
	23
	24	Rectangle {
	25	width: 400
	26	height: 300
	27
	28	ChartView {
	29	id: chartView
	30	anchors.fill: parent
	31	title: "Oscilloscope"
	32	animationOptions: ChartView.NoAnimation
	33
	34	ValuesAxis {
	35	id: axisY
	36	min: -1
	37	max: 3
	38	}
	39
	40	ValuesAxis {
	41	id: axisX
	42	min: 0
	43	max: 1000
	44	}
	45
	46	LineSeries {
	47	id: lineSeries1
	48	name: "signal 1"
	49	}
	50	LineSeries {
	51	id: lineSeries2
	52	name: "signal 2"
	53	}
	54	}
	55
	56	Timer {
	57	interval: 16 // 60 Hz
	58	running: true
	59	repeat: true
	60	onTriggered: {
	61	dataSource.update(lineSeries1);
	62	dataSource.update(lineSeries2);
	63	}
	64	}
	65
	66	Component.onCompleted: {
	67	chartView.setAxisX(axisX, lineSeries1);
	68	chartView.setAxisY(axisY, lineSeries1);
	69	chartView.setAxisX(axisX, lineSeries2);
	70	chartView.setAxisY(axisY, lineSeries2);
	71	}
	72	}

demos/qmloscilloscope/qmlapplicationviewer/qmlapplicationviewer.cpp created 644 +200 0

@@ -0,0 +1,200
	1	// checksum 0x78c version 0x60010
	2	/*
	3	This file was generated by the Qt Quick Application wizard of Qt Creator.
	4	QmlApplicationViewer is a convenience class containing mobile device specific
	5	code such as screen orientation handling. Also QML paths and debugging are
	6	handled here.
	7	It is recommended not to modify this file, since newer versions of Qt Creator
	8	may offer an updated version of it.
	9	*/
	10
	11	#include "qmlapplicationviewer.h"
	12
	13	#include <QtCore/QDir>
	14	#include <QtCore/QFileInfo>
	15	#include <QtDeclarative/QDeclarativeComponent>
	16	#include <QtDeclarative/QDeclarativeEngine>
	17	#include <QtDeclarative/QDeclarativeContext>
	18	#include <QtGui/QApplication>
	19
	20	#include <qplatformdefs.h> // MEEGO_EDITION_HARMATTAN
	21
	22	#ifdef HARMATTAN_BOOSTER
	23	#include <MDeclarativeCache>
	24	#endif
	25
	26	#if defined(QMLJSDEBUGGER) && QT_VERSION < 0x040800
	27
	28	#include <qt_private/qdeclarativedebughelper_p.h>
	29
	30	#if !defined(NO_JSDEBUGGER)
	31	#include <jsdebuggeragent.h>
	32	#endif
	33	#if !defined(NO_QMLOBSERVER)
	34	#include <qdeclarativeviewobserver.h>
	35	#endif
	36
	37	// Enable debugging before any QDeclarativeEngine is created
	38	struct QmlJsDebuggingEnabler
	39	{
	40	QmlJsDebuggingEnabler()
	41	{
	42	QDeclarativeDebugHelper::enableDebugging();
	43	}
	44	};
	45
	46	// Execute code in constructor before first QDeclarativeEngine is instantiated
	47	static QmlJsDebuggingEnabler enableDebuggingHelper;
	48
	49	#endif // QMLJSDEBUGGER
	50
	51	class QmlApplicationViewerPrivate
	52	{
	53	QmlApplicationViewerPrivate(QDeclarativeView *view_) : view(view_) {}
	54
	55	QString mainQmlFile;
	56	QDeclarativeView *view;
	57	friend class QmlApplicationViewer;
	58	QString adjustPath(const QString &path);
	59	};
	60
	61	QString QmlApplicationViewerPrivate::adjustPath(const QString &path)
	62	{
	63	#ifdef Q_OS_UNIX
	64	#ifdef Q_OS_MAC
	65	if (!QDir::isAbsolutePath(path))
	66	return QCoreApplication::applicationDirPath()
	67	+ QLatin1String("/../Resources/") + path;
	68	#else
	69	QString pathInInstallDir;
	70	const QString applicationDirPath = QCoreApplication::applicationDirPath();
	71	pathInInstallDir = QString::fromAscii("%1/../%2").arg(applicationDirPath, path);
	72
	73	if (QFileInfo(pathInInstallDir).exists())
	74	return pathInInstallDir;
	75	#endif
	76	#endif
	77	return path;
	78	}
	79
	80	QmlApplicationViewer::QmlApplicationViewer(QWidget *parent)
	81	: QDeclarativeView(parent)
	82	, d(new QmlApplicationViewerPrivate(this))
	83	{
	84	connect(engine(), SIGNAL(quit()), SLOT(close()));
	85	setResizeMode(QDeclarativeView::SizeRootObjectToView);
	86	// Qt versions prior to 4.8.0 don't have QML/JS debugging services built in
	87	#if defined(QMLJSDEBUGGER) && QT_VERSION < 0x040800
	88	#if !defined(NO_JSDEBUGGER)
	89	new QmlJSDebugger::JSDebuggerAgent(d->view->engine());
	90	#endif
	91	#if !defined(NO_QMLOBSERVER)
	92	new QmlJSDebugger::QDeclarativeViewObserver(d->view, d->view);
	93	#endif
	94	#endif
	95	}
	96
	97	QmlApplicationViewer::QmlApplicationViewer(QDeclarativeView view, QWidget parent)
	98	: QDeclarativeView(parent)
	99	, d(new QmlApplicationViewerPrivate(view))
	100	{
	101	connect(view->engine(), SIGNAL(quit()), view, SLOT(close()));
	102	view->setResizeMode(QDeclarativeView::SizeRootObjectToView);
	103	// Qt versions prior to 4.8.0 don't have QML/JS debugging services built in
	104	#if defined(QMLJSDEBUGGER) && QT_VERSION < 0x040800
	105	#if !defined(NO_JSDEBUGGER)
	106	new QmlJSDebugger::JSDebuggerAgent(d->view->engine());
	107	#endif
	108	#if !defined(NO_QMLOBSERVER)
	109	new QmlJSDebugger::QDeclarativeViewObserver(d->view, d->view);
	110	#endif
	111	#endif
	112	}
	113
	114	QmlApplicationViewer::~QmlApplicationViewer()
	115	{
	116	delete d;
	117	}
	118
	119	QmlApplicationViewer *QmlApplicationViewer::create()
	120	{
	121	#ifdef HARMATTAN_BOOSTER
	122	return new QmlApplicationViewer(MDeclarativeCache::qDeclarativeView(), 0);
	123	#else
	124	return new QmlApplicationViewer();
	125	#endif
	126	}
	127
	128	void QmlApplicationViewer::setMainQmlFile(const QString &file)
	129	{
	130	d->mainQmlFile = d->adjustPath(file);
	131	d->view->setSource(QUrl::fromLocalFile(d->mainQmlFile));
	132	}
	133
	134	void QmlApplicationViewer::addImportPath(const QString &path)
	135	{
	136	d->view->engine()->addImportPath(d->adjustPath(path));
	137	}
	138
	139	void QmlApplicationViewer::setOrientation(ScreenOrientation orientation)
	140	{
	141	#if defined(Q_OS_SYMBIAN)
	142	// If the version of Qt on the device is < 4.7.2, that attribute won't work
	143	if (orientation != ScreenOrientationAuto) {
	144	const QStringList v = QString::fromAscii(qVersion()).split(QLatin1Char('.'));
	145	if (v.count() == 3 && (v.at(0).toInt() << 16 \| v.at(1).toInt() << 8 \| v.at(2).toInt()) < 0x040702) {
	146	qWarning("Screen orientation locking only supported with Qt 4.7.2 and above");
	147	return;
	148	}
	149	}
	150	#endif // Q_OS_SYMBIAN
	151
	152	Qt::WidgetAttribute attribute;
	153	switch (orientation) {
	154	#if QT_VERSION < 0x040702
	155	// Qt < 4.7.2 does not yet have the Qt::WA_*Orientation attributes
	156	case ScreenOrientationLockPortrait:
	157	attribute = static_cast<Qt::WidgetAttribute>(128);
	158	break;
	159	case ScreenOrientationLockLandscape:
	160	attribute = static_cast<Qt::WidgetAttribute>(129);
	161	break;
	162	default:
	163	case ScreenOrientationAuto:
	164	attribute = static_cast<Qt::WidgetAttribute>(130);
	165	break;
	166	#else // QT_VERSION < 0x040702
	167	case ScreenOrientationLockPortrait:
	168	attribute = Qt::WA_LockPortraitOrientation;
	169	break;
	170	case ScreenOrientationLockLandscape:
	171	attribute = Qt::WA_LockLandscapeOrientation;
	172	break;
	173	default:
	174	case ScreenOrientationAuto:
	175	attribute = Qt::WA_AutoOrientation;
	176	break;
	177	#endif // QT_VERSION < 0x040702
	178	};
	179	setAttribute(attribute, true);
	180	}
	181
	182	void QmlApplicationViewer::showExpanded()
	183	{
	184	#if defined(Q_OS_SYMBIAN) \|\| defined(MEEGO_EDITION_HARMATTAN) \|\| defined(Q_WS_SIMULATOR)
	185	d->view->showFullScreen();
	186	#elif defined(Q_WS_MAEMO_5)
	187	d->view->showMaximized();
	188	#else
	189	d->view->show();
	190	#endif
	191	}
	192
	193	QApplication createApplication(int &argc, char *argv)
	194	{
	195	#ifdef HARMATTAN_BOOSTER
	196	return MDeclarativeCache::qApplication(argc, argv);
	197	#else
	198	return new QApplication(argc, argv);
	199	#endif
	200	}

demos/qmloscilloscope/qmlapplicationviewer/qmlapplicationviewer.h created 644 +47 0

@@ -0,0 +1,47
	1	// checksum 0x82ed version 0x60010
	2	/*
	3	This file was generated by the Qt Quick Application wizard of Qt Creator.
	4	QmlApplicationViewer is a convenience class containing mobile device specific
	5	code such as screen orientation handling. Also QML paths and debugging are
	6	handled here.
	7	It is recommended not to modify this file, since newer versions of Qt Creator
	8	may offer an updated version of it.
	9	*/
	10
	11	#ifndef QMLAPPLICATIONVIEWER_H
	12	#define QMLAPPLICATIONVIEWER_H
	13
	14	#include <QtDeclarative/QDeclarativeView>
	15
	16	class QmlApplicationViewer : public QDeclarativeView
	17	{
	18	Q_OBJECT
	19
	20	public:
	21	enum ScreenOrientation {
	22	ScreenOrientationLockPortrait,
	23	ScreenOrientationLockLandscape,
	24	ScreenOrientationAuto
	25	};
	26
	27	explicit QmlApplicationViewer(QWidget *parent = 0);
	28	virtual ~QmlApplicationViewer();
	29
	30	static QmlApplicationViewer *create();
	31
	32	void setMainQmlFile(const QString &file);
	33	void addImportPath(const QString &path);
	34
	35	// Note that this will only have an effect on Symbian and Fremantle.
	36	void setOrientation(ScreenOrientation orientation);
	37
	38	void showExpanded();
	39
	40	private:
	41	explicit QmlApplicationViewer(QDeclarativeView view, QWidget parent);
	42	class QmlApplicationViewerPrivate *d;
	43	};
	44
	45	QApplication createApplication(int &argc, char *argv);
	46
	47	#endif // QMLAPPLICATIONVIEWER_H

demos/qmloscilloscope/qmlapplicationviewer/qmlapplicationviewer.pri created 644 +13 0

@@ -0,0 +1,13
	1	QT += declarative
	2
	3	SOURCES += $$PWD/qmlapplicationviewer.cpp
	4	HEADERS += $$PWD/qmlapplicationviewer.h
	5	INCLUDEPATH += $$PWD
	6
	7	# Include JS debugger library if QMLJSDEBUGGER_PATH is set
	8	!isEmpty(QMLJSDEBUGGER_PATH) {
	9	include($$QMLJSDEBUGGER_PATH/qmljsdebugger-lib.pri)
	10	} else {
	11	DEFINES -= QMLJSDEBUGGER
	12	}
	13

demos/qmloscilloscope/qmloscilloscope.pro created 644 +13 0

@@ -0,0 +1,13
	1	!include( ../demos.pri ) {
	2	error( "Couldn't find the demos.pri file!" )
	3	}
	4
	5	QT += opengl
	6	RESOURCES += resources.qrc
	7	SOURCES += main.cpp \
	8	datasource.cpp
	9
	10	include(qmlapplicationviewer/qmlapplicationviewer.pri)
	11
	12	HEADERS += \
	13	datasource.h

demos/qmloscilloscope/resources.qrc created 644 +5 0

@@ -0,0 +1,5
	1	<RCC>
	2	<qresource prefix="/">
	3	<file>qml/qmloscilloscope/main.qml</file>
	4	</qresource>
	5	</RCC>

demos/demos.pro +2 -1

             CURRENTLY_BUILDING_COMPONENTS = "demos"
             !include( ../config.pri ) {
                 error( "Couldn't find the config.pri file!" )
             }
             TEMPLATE = subdirs
             SUBDIRS += chartthemes \
                        piechartcustomization \
                        dynamicspline \
                        qmlchart \
                        qmlweather \
                        qmlf1legends \
                        qmlcustomizations \
                        qmlcustommodel \
-                       chartviewer
  No newline at end of file
+                       qmloscilloscope \
+                       chartviewer

src/splinechart/qsplineseries.cpp +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qsplineseries.h"
             #include "qsplineseries_p.h"
             #include "splinechartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "splineanimation_p.h"
             /*!
                 \class QSplineSeries
                 \brief Series type used to store data needed to draw a spline.
                 QSplineSeries stores the data points along with the segment control points needed by QPainterPath to draw spline
                 Control points are automatically calculated when data changes. The algorithm computes the points so that the normal spline can be drawn.
                 \image examples_splinechart.png
                 Creating basic spline chart is simple:
                 \code
                 QSplineSeries* series = new QSplineSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chart->addSeries(series);
                 \endcode
             */
             /*!
                 \qmlclass SplineSeries QSplineSeries
                 \inherits XYSeries
                 The following QML shows how to create a simple spline chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View3.qml 1
                 \beginfloatleft
                 \image demos_qmlchart3.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \fn QSeriesType QSplineSeries::type() const
                 Returns the type of the series
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance then the ownerships is transferred.
               */
             QSplineSeries::QSplineSeries(QObject *parent) :
                 QLineSeries(*new QSplineSeriesPrivate(this),parent)
             {
                 Q_D(QSplineSeries);
                 QObject::connect(this,SIGNAL(pointAdded(int)), d, SLOT(updateControlPoints()));
                 QObject::connect(this,SIGNAL(pointRemoved(int)), d, SLOT(updateControlPoints()));
                 QObject::connect(this,SIGNAL(pointReplaced(int)), d, SLOT(updateControlPoints()));
+                QObject::connect(this,SIGNAL(pointsReplaced()), d, SLOT(updateControlPoints()));
             }
             /*!
               Destroys the object.
             */
             QSplineSeries::~QSplineSeries()
             {
                 Q_D(QSplineSeries);
                 if(d->m_dataset){
                     d->m_dataset->removeSeries(this);
                 }
             }
             QAbstractSeries::SeriesType QSplineSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeSpline;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QSplineSeriesPrivate::QSplineSeriesPrivate(QSplineSeries* q):QLineSeriesPrivate(q)
             {
             }
             /*!
               Calculates control points which are needed by QPainterPath.cubicTo function to draw the cubic Bezier cureve between two points.
               */
             void QSplineSeriesPrivate::calculateControlPoints()
             {
                 Q_Q(QSplineSeries);
                 const QList<QPointF>& points = q->points();
                 int n = points.count() - 1;
                 if (n == 1)
                 {
                     //for n==1
                     m_controlPoints[0].setX((2 * points[0].x() + points[1].x()) / 3);
                     m_controlPoints[0].setY((2 * points[0].y() + points[1].y()) / 3);
                     m_controlPoints[1].setX(2 * m_controlPoints[0].x() - points[0].x());
                     m_controlPoints[1].setY(2 * m_controlPoints[0].y() - points[0].y());
                     return;
                 }
                 // Calculate first Bezier control points
                 // Set of equations for P0 to Pn points.
                 //
                 //  |   2   1   0   0   ... 0   0   0   ... 0   0   0   |   |   P1_1    |   |   P0 + 2 * P1             |
                 //  |   1   4   1   0   ... 0   0   0   ... 0   0   0   |   |   P1_2    |   |   4 * P1 + 2 * P2         |
                 //  |   0   1   4   1   ... 0   0   0   ... 0   0   0   |   |   P1_3    |   |   4 * P2 + 2 * P3         |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   ... 1   4   1   ... 0   0   0   | * |   P1_i    | = |   4 * P(i-1) + 2 * Pi     |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   0   0   0   0   ... 1   4   1   |   |   P1_(n-1)|   |   4 * P(n-2) + 2 * P(n-1) |
                 //  |   0   0   0   0   0   0   0   0   ... 0   2   7   |   |   P1_n    |   |   8 * P(n-1) + Pn         |
                 //
                 QVector<qreal> vector;
                 vector.resize(n);
                 vector[0] = points[0].x() + 2 * points[1].x();
                 for (int i = 1; i < n - 1; ++i){
                     vector[i] = 4 * points[i].x() + 2 * points[i + 1].x();
                 }
                 vector[n - 1] = (8 * points[n-1].x() + points[n].x()) / 2.0;
                 QVector<qreal> xControl = firstControlPoints(vector);
                 vector[0] = points[0].y() + 2 * points[1].y();
                 for (int i = 1; i < n - 1; ++i) {
                     vector[i] = 4 * points[i].y() + 2 * points[i + 1].y();
                 }
                 vector[n - 1] = (8 * points[n-1].y() + points[n].y()) / 2.0;
                 QVector<qreal> yControl = firstControlPoints(vector);
                 for (int i = 0,j =0; i < n; ++i, ++j) {
                     m_controlPoints[j].setX(xControl[i]);
                     m_controlPoints[j].setY(yControl[i]);
                     j++;
                     if (i < n - 1){
                         m_controlPoints[j].setX(2 * points[i+1].x() - xControl[i + 1]);
                         m_controlPoints[j].setY(2 * points[i+1].y() - yControl[i + 1]);
                     }else{
                         m_controlPoints[j].setX((points[n].x() + xControl[n - 1]) / 2);
                         m_controlPoints[j].setY((points[n].y() + yControl[n - 1]) / 2);
                     }
                 }
             }
             QVector<qreal> QSplineSeriesPrivate::firstControlPoints(const QVector<qreal>& vector)
             {
                 QVector<qreal> result;
                 int count = vector.count();
                 result.resize(count);
                 result[0] = vector[0] / 2.0;
                 QVector<qreal> temp;
                 temp.resize(count);
                 temp[0] = 0;
                 qreal b = 2.0;
                 for (int i = 1; i < count; i++) {
                     temp[i] = 1 / b;
                     b = (i < count - 1 ? 4.0 : 3.5) - temp[i];
                     result[i]=(vector[i] - result[i - 1]) / b;
                 }
                 for (int i = 1; i < count; i++)
                     result[count - i - 1] -= temp[count - i] * result[count - i];
                 return result;
             }
             QPointF QSplineSeriesPrivate::controlPoint(int index) const
             {
                 return m_controlPoints[index];
             }
             /*!
               Updates the control points, besed on currently avaiable knots.
               */
             void QSplineSeriesPrivate::updateControlPoints()
             {
                 Q_Q(QSplineSeries);
                 if (q->count() > 1) {
                     m_controlPoints.resize(2*q->count()-2);
                     calculateControlPoints();
                 }
             }
             ChartElement* QSplineSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QSplineSeries);
                 SplineChartItem* spline  = new SplineChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     spline->setAnimation(new SplineAnimation(spline));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return spline;
             }
             #include "moc_qsplineseries.cpp"
             #include "moc_qsplineseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.cpp +24 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include "qvaluesaxis.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.
             */
             /*!
                 \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::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 another 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 QChartView or QChart instance ownerships is transferred.
             */
             QXYSeries::QXYSeries(QXYSeriesPrivate &d,QObject *parent) : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(qreal x,qreal y)
             {
                 append(QPointF(x,y));
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 d->m_points<<point;
-            //    emit d->pointAdded(d->m_points.count()-1);
                 emit pointAdded(d->m_points.count()-1);
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series. Points are connected with lines on the chart.
              */
             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;
                 d->m_points[index] = newPoint;
                 emit pointReplaced(index);
             }
             /*!
+              Replaces the current points with \a points. This is 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 current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x,qreal y)
             {
                 remove(QPointF(x,y));
             }
             /*!
               Removes current \a point x value.
               Note: point y value is ignored.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if(index==-1) return;
                 d->m_points.remove(index);
-            //    emit d->pointRemoved(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);
                 d->m_points.insert(index, point);
-            //    emit d->pointAdded(index);
                 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 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::scaleDomain(Domain& domain)
             {
                 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<LegendMarker*> QXYSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<LegendMarker*> list;
                 return list << new XYLegendMarker(q,legend);
             }
             void QXYSeriesPrivate::initializeAxis(QAbstractAxis* axis)
             {
                 Q_UNUSED(axis);
             }
             QAbstractAxis::AxisType QXYSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValues;
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.h +3 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef 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 remove(qreal x, qreal y);
                 void remove(const QPointF &point);
                 void insert(int index, const QPointF &point);
                 void clear();
                 int count() const;
                 QList<QPointF> points() 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 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 XYLegendMarker;
                 friend class XYChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xychart/xychart.cpp +8 0

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "xychart_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "chartpresenter_p.h"
             #include "domain_p.h"
             #include "qxymodelmapper.h"
             #include <QPainter>
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             XYChart::XYChart(QXYSeries *series, ChartPresenter *presenter):ChartElement(presenter),
             m_minX(0),
             m_maxX(0),
             m_minY(0),
             m_maxY(0),
             m_series(series),
             m_animation(0),
             m_dirty(true)
             {
                 QObject::connect(series, SIGNAL(pointReplaced(int)), this, SLOT(handlePointReplaced(int)));
+                QObject::connect(series, SIGNAL(pointsReplaced()), this, SLOT(handlePointsReplaced()));
                 QObject::connect(series, SIGNAL(pointAdded(int)), this, SLOT(handlePointAdded(int)));
                 QObject::connect(series, SIGNAL(pointRemoved(int)), this, SLOT(handlePointRemoved(int)));
                 QObject::connect(this, SIGNAL(clicked(QPointF)), series, SIGNAL(clicked(QPointF)));
             }
             void XYChart::setGeometryPoints(const QVector<QPointF>& points)
             {
                 m_points = points;
             }
             void XYChart::setClipRect(const QRectF &rect)
             {
                 m_clipRect = rect;
             }
             void XYChart::setAnimation(XYAnimation* animation)
             {
                 m_animation=animation;
             }
             void XYChart::setDirty(bool dirty)
             {
             	m_dirty=dirty;
             }
             QPointF XYChart::calculateGeometryPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = (point.x() - m_minX)* deltaX;
                 qreal y = (point.y() - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QPointF XYChart::calculateGeometryPoint(int index) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 const QList<QPointF>& vector = m_series->points();
                 qreal x = (vector[index].x() - m_minX)* deltaX;
                 qreal y = (vector[index].y() - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QVector<QPointF> XYChart::calculateGeometryPoints() const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 QVector<QPointF> result;
                 result.resize(m_series->count());
                 const QList<QPointF>& vector = m_series->points();
                 for (int i = 0; i < m_series->count(); ++i) {
                     qreal x = (vector[i].x() - m_minX)* deltaX;
                     qreal y = (vector[i].y() - m_minY)*-deltaY + m_size.height();
                     result[i].setX(x);
                     result[i].setY(y);
                 }
                 return result;
             }
             QPointF XYChart::calculateDomainPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = point.x()/deltaX +m_minX;
                 qreal y = (point.y()-m_size.height())/(-deltaY)+ m_minY;
                 return QPointF(x,y);
             }
             void XYChart::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
             {
                 if (m_animation) {
                     m_animation->setup(oldPoints, newPoints, index);
                     m_points = newPoints;
                     setDirty(false);
                     presenter()->startAnimation(m_animation);
                 }
                 else {
                     m_points = newPoints;
                     updateGeometry();
                 }
             }
             //handlers
             void XYChart::handlePointAdded(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QVector<QPointF> points;
             	if(m_dirty) {
             		points = calculateGeometryPoints();
             	} else {
             		points = m_points;
             		QPointF point = calculateGeometryPoint(index);
             		points.insert(index, point);
             	}
                 updateChart(m_points,points,index);
             }
             void XYChart::handlePointRemoved(int index)
             {
             	Q_ASSERT(index<=m_series->count());
             	Q_ASSERT(index>=0);
             	QVector<QPointF> points;
             	if(m_dirty) {
             		points = calculateGeometryPoints();
             	} else {
             		points = m_points;
             		points.remove(index);
             	}
             	updateChart(m_points,points,index);
             }
             void XYChart::handlePointReplaced(int index)
             {
             	Q_ASSERT(index<m_series->count());
             	Q_ASSERT(index>=0);
             	QVector<QPointF> points;
             	if(m_dirty) {
             		points = calculateGeometryPoints();
             	} else {
             		QPointF point = calculateGeometryPoint(index);
             		points = m_points;
             		points.replace(index,point);
             	}
             	updateChart(m_points,points,index);
             }
+            void XYChart::handlePointsReplaced()
+            {
+                // All the points were replaced -> recalculate
+                QVector<QPointF> points = calculateGeometryPoints();
+                updateChart(m_points, points, -1);
+            }
             void XYChart::handleDomainUpdated()
             {
                 m_minX=domain()->minX();
                 m_maxX=domain()->maxX();
                 m_minY=domain()->minY();
                 m_maxY=domain()->maxY();
                 if (isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 updateChart(m_points,points);
             }
             void XYChart::handleGeometryChanged(const QRectF &rect)
             {
                 Q_ASSERT(rect.isValid());
                 m_size=rect.size();
                 m_clipRect=rect.translated(-rect.topLeft());
                 m_origin=rect.topLeft();
                 if (isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 updateChart(m_points,points);
             }
             bool XYChart::isEmpty()
             {
                 return !m_clipRect.isValid() || qFuzzyIsNull(m_maxX - m_minX) || qFuzzyIsNull(m_maxY - m_minY) || m_series->points().isEmpty();
             }
             #include "moc_xychart_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/xychart_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef XYCHARTITEM_H
             #define XYCHARTITEM_H
             #include "qchartglobal.h"
             #include "chartitem_p.h"
             #include "xyanimation_p.h"
             #include "qvaluesaxis.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QXYSeries;
             class XYChart :  public ChartElement
             {
                  Q_OBJECT
             public:
                  explicit XYChart(QXYSeries *series, ChartPresenter *presenter);
                 ~XYChart() {}
                 void setGeometryPoints(const QVector<QPointF>& points);
                 QVector<QPointF> geometryPoints() const { return m_points; }
                 void setClipRect(const QRectF &rect);
                 QRectF clipRect() const { return m_clipRect; }
                 QSizeF size() const { return m_size; }
                 QPointF origin() const { return m_origin; }
                 void setAnimation(XYAnimation* animation);
                 ChartAnimation* animation() const { return m_animation; }
                 virtual void updateGeometry() = 0;
                 bool isDirty() const { return m_dirty; }
                 void setDirty(bool dirty);
             public Q_SLOTS:
                 void handlePointAdded(int index);
                 void handlePointRemoved(int index);
                 void handlePointReplaced(int index);
+                void handlePointsReplaced();
                 void handleDomainUpdated();
                 void handleGeometryChanged(const QRectF &size);
             Q_SIGNALS:
                 void clicked(const QPointF& point);
             protected:
                 virtual void updateChart(QVector<QPointF> &oldPoints,QVector<QPointF> &newPoints,int index = -1);
                 QPointF calculateGeometryPoint(const QPointF &point) const;
                 QPointF calculateGeometryPoint(int index) const;
                 QPointF calculateDomainPoint(const QPointF &point) const;
                 QVector<QPointF> calculateGeometryPoints() const;
             private:
                 inline bool isEmpty();
             protected:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 QXYSeries* m_series;
                 QSizeF m_size;
                 QPointF m_origin;
                 QRectF m_clipRect;
                 QVector<QPointF> m_points;
                 XYAnimation* m_animation;
                 bool m_dirty;
                 friend class AreaChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

tests/auto/qxyseries/tst_qxyseries.cpp +16 -6

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "tst_qxyseries.h"
             Q_DECLARE_METATYPE(QList<QPointF>)
             void tst_QXYSeries::initTestCase()
             {
             }
             void tst_QXYSeries::cleanupTestCase()
             {
             }
             void tst_QXYSeries::init()
             {
                 m_view = new QChartView(new QChart());
                 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::append_data()
             {
                 QTest::addColumn< QList<QPointF> >("points");
                 QTest::newRow("0,0 1,1 2,2 3,3") << (QList<QPointF>() << QPointF(0,0) << QPointF(1,1) << QPointF(2,2) << QPointF(3,3));
                 QTest::newRow("0,0 -1,-1 -2,-2 -3,-3") << (QList<QPointF>() << QPointF(0,0) << QPointF(-1,-1) << QPointF(-2,-2) << QPointF(-3,-3));
             }
             void tst_QXYSeries::append_raw_data()
             {
                 append_data();
             }
             void tst_QXYSeries::append_raw()
             {
                 QFETCH(QList<QPointF>, points);
                 QSignalSpy spy0(m_series, SIGNAL(clicked(QPointF const&)));
                 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);
             }
             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 const&)));
                 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 const&)));
                 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);
             }
             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 const&)));
                 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);
             }
             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);
-                QSignalSpy replacedSpy(m_series, SIGNAL(pointReplaced(int)));
+                QSignalSpy pointReplacedSpy(m_series, SIGNAL(pointReplaced(int)));
+                QSignalSpy pointsReplacedSpy(m_series, SIGNAL(pointsReplaced()));
                 m_series->append(points);
-                TRY_COMPARE(replacedSpy.count(), 0);
+                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(replacedSpy.count(), points.count());
+                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(replacedSpy.count(), points.count());
+                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);
             }
             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 const&)));
                 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 const&)));
                 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 const&)));
                 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);
             }

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