HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2820:79a856530b69

Accelerating lineseries with OpenGL...

Miikka Heikkinen -

r2820:79a856530b69

parent child

Context file:

r2820:79a856530b69

Expand all files

examples/charts/openglseries/datasource.cpp created 644 +118 0

@@ -0,0 +1,118
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#include "datasource.h"
	20	#include <QtCore/QtMath>
	21
	22	QT_CHARTS_USE_NAMESPACE
	23
	24	DataSource::DataSource(QObject *parent) :
	25	QObject(parent),
	26	m_index(-1)
	27	{
	28	generateData(0, 0, 0);
	29	}
	30
	31	void DataSource::update(QAbstractSeries *series, int seriesIndex)
	32	{
	33	if (series) {
	34	QXYSeries xySeries = static_cast<QXYSeries >(series);
	35	const QVector<QVector<QPointF> > &seriesData = m_data.at(seriesIndex);
	36	if (seriesIndex == 0)
	37	m_index++;
	38	if (m_index > seriesData.count() - 1)
	39	m_index = 0;
	40
	41	QVector<QPointF> points = seriesData.at(m_index);
	42	// Use replace instead of clear + append, it's optimized for performance
	43	xySeries->replace(points);
	44	}
	45	}
	46
	47	void DataSource::handleSceneChanged()
	48	{
	49	m_dataUpdater.start();
	50	}
	51
	52	void DataSource::updateAllSeries()
	53	{
	54	static int frameCount = 0;
	55	static QString labelText = QStringLiteral("FPS: %1");
	56
	57	for (int i = 0; i < m_seriesList.size(); i++)
	58	update(m_seriesList[i], i);
	59
	60	frameCount++;
	61	int elapsed = m_fpsTimer.elapsed();
	62	if (elapsed >= 1000) {
	63	elapsed = m_fpsTimer.restart();
	64	qreal fps = qreal(0.1 * int(10000.0 * (qreal(frameCount) / qreal(elapsed))));
	65	m_fpsLabel->setText(labelText.arg(QString::number(fps, 'f', 1)));
	66	frameCount = 0;
	67	}
	68	}
	69
	70	void DataSource::startUpdates(const QList<QXYSeries > &seriesList, QLabel fpsLabel)
	71	{
	72	m_seriesList = seriesList;
	73	m_fpsLabel = fpsLabel;
	74
	75	m_dataUpdater.setInterval(0);
	76	m_dataUpdater.setSingleShot(true);
	77	QObject::connect(&m_dataUpdater, &QTimer::timeout,
	78	this, &DataSource::updateAllSeries);
	79
	80	m_fpsTimer.start();
	81	updateAllSeries();
	82	}
	83
	84	void DataSource::generateData(int seriesCount, int rowCount, int colCount)
	85	{
	86	// Remove previous data
	87	foreach (QVector<QVector<QPointF> > seriesData, m_data) {
	88	foreach (QVector<QPointF> row, seriesData)
	89	row.clear();
	90	}
	91
	92	m_data.clear();
	93
	94	qreal xAdjustment = 20.0 / (colCount * rowCount);
	95	qreal yMultiplier = 3.0 / qreal(seriesCount);
	96
	97	// Append the new data depending on the type
	98	for (int k(0); k < seriesCount; k++) {
	99	QVector<QVector<QPointF> > seriesData;
	100	qreal height = qreal(k) * (10.0 / qreal(seriesCount)) + 0.3;
	101	for (int i(0); i < rowCount; i++) {
	102	QVector<QPointF> points;
	103	points.reserve(colCount);
	104	for (int j(0); j < colCount; j++) {
	105	qreal x(0);
	106	qreal y(0);
	107	// data with sin + random component
	108	y = height + (yMultiplier * qSin(3.14159265358979 / 50 * j)
	109	+ (yMultiplier * (qreal) rand() / (qreal) RAND_MAX));
	110	// 0.000001 added to make values logaxis compatible
	111	x = 0.000001 + 20.0 * (qreal(j) / qreal(colCount)) + (xAdjustment * qreal(i));
	112	points.append(QPointF(x, y));
	113	}
	114	seriesData.append(points);
	115	}
	116	m_data.append(seriesData);
	117	}
	118	}

examples/charts/openglseries/datasource.h created 644 +53 0

@@ -0,0 +1,53
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#ifndef DATASOURCE_H
	20	#define DATASOURCE_H
	21
	22	#include <QtCore/QObject>
	23	#include <QtCharts/QXYSeries>
	24	#include <QtWidgets/QLabel>
	25	#include <QtCore/QElapsedTimer>
	26	#include <QtCore/QTimer>
	27
	28	QT_CHARTS_USE_NAMESPACE
	29
	30	class DataSource : public QObject
	31	{
	32	Q_OBJECT
	33	public:
	34	explicit DataSource(QObject *parent = 0);
	35
	36	void startUpdates(const QList<QXYSeries > &seriesList, QLabel fpsLabel);
	37
	38	public slots:
	39	void generateData(int seriesCount, int rowCount, int colCount);
	40	void update(QAbstractSeries *series, int seriesIndex);
	41	void handleSceneChanged();
	42	void updateAllSeries();
	43
	44	private:
	45	QVector<QVector<QVector<QPointF> > > m_data;
	46	int m_index;
	47	QList<QXYSeries *> m_seriesList;
	48	QLabel *m_fpsLabel;
	49	QElapsedTimer m_fpsTimer;
	50	QTimer m_dataUpdater;
	51	};
	52
	53	#endif // DATASOURCE_H

examples/charts/openglseries/main.cpp created 644 +167 0

@@ -0,0 +1,167
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#include "datasource.h"
	20	#include <QtWidgets/QApplication>
	21	#include <QtWidgets/QMainWindow>
	22	#include <QtCharts/QChartView>
	23	#include <QtCharts/QLineSeries>
	24	#include <QtCharts/QScatterSeries>
	25	#include <QtCharts/QValueAxis>
	26	#include <QtCharts/QLogValueAxis>
	27	#include <QtWidgets/QLabel>
	28
	29	// Uncomment to use logarithmic axes instead of regular value axes
	30	//#define USE_LOG_AXIS
	31
	32	// Uncomment to use regular series instead of OpenGL accelerated series
	33	//#define DONT_USE_GL_SERIES
	34
	35	// Uncomment to add a simple regular series (thick line) and a matching OpenGL series (thinner line)
	36	// to verify the series have same visible geometry.
	37	//#define ADD_SIMPLE_SERIES
	38
	39	QT_CHARTS_USE_NAMESPACE
	40
	41	int main(int argc, char *argv[])
	42	{
	43	QApplication a(argc, argv);
	44	QStringList colors;
	45	colors << "red" << "blue" << "green" << "black";
	46
	47	QChart *chart = new QChart();
	48	chart->legend()->hide();
	49
	50	#ifdef USE_LOG_AXIS
	51	QLogValueAxis *axisX = new QLogValueAxis;
	52	QLogValueAxis *axisY = new QLogValueAxis;
	53	#else
	54	QValueAxis *axisX = new QValueAxis;
	55	QValueAxis *axisY = new QValueAxis;
	56	#endif
	57
	58	chart->addAxis(axisX, Qt::AlignBottom);
	59	chart->addAxis(axisY, Qt::AlignLeft);
	60
	61	const int seriesCount = 10;
	62	#ifdef DONT_USE_GL_SERIES
	63	const int pointCount = 100;
	64	chart->setTitle("Unaccelerated Series");
	65	#else
	66	const int pointCount = 10000;
	67	chart->setTitle("OpenGL Accelerated Series");
	68	#endif
	69
	70	QList<QXYSeries *> seriesList;
	71	for (int i = 0; i < seriesCount; i++) {
	72	QXYSeries *series = 0;
	73	int colorIndex = i % colors.size();
	74	if (i % 2) {
	75	series = new QScatterSeries;
	76	QScatterSeries scatter = static_cast<QScatterSeries >(series);
	77	scatter->setColor(QColor(colors.at(colorIndex)));
	78	scatter->setMarkerSize(qreal(colorIndex + 2) / 2.0);
	79	// Scatter pen doesn't have affect in OpenGL drawing, but if you disable OpenGL drawing
	80	// this makes the marker border visible and gives comparable marker size to OpenGL
	81	// scatter points.
	82	scatter->setPen(QPen("black"));
	83	} else {
	84	series = new QLineSeries;
	85	series->setPen(QPen(QBrush(QColor(colors.at(colorIndex))),
	86	qreal(colorIndex + 2) / 2.0));
	87	}
	88	seriesList.append(series);
	89	#ifdef DONT_USE_GL_SERIES
	90	series->setUseOpenGL(false);
	91	#else
	92	//![1]
	93	series->setUseOpenGL(true);
	94	//![1]
	95	#endif
	96	chart->addSeries(series);
	97	series->attachAxis(axisX);
	98	series->attachAxis(axisY);
	99	}
	100
	101	if (axisX->type() == QAbstractAxis::AxisTypeLogValue)
	102	axisX->setRange(0.1, 20.0);
	103	else
	104	axisX->setRange(0, 20.0);
	105
	106	if (axisY->type() == QAbstractAxis::AxisTypeLogValue)
	107	axisY->setRange(0.1, 10.0);
	108	else
	109	axisY->setRange(0, 10.0);
	110
	111	#ifdef ADD_SIMPLE_SERIES
	112	QLineSeries *simpleRasterSeries = new QLineSeries;
	113	*simpleRasterSeries << QPointF(0.001, 0.001)
	114	<< QPointF(2.5, 8.0)
	115	<< QPointF(5.0, 4.0)
	116	<< QPointF(7.5, 9.0)
	117	<< QPointF(10.0, 0.001)
	118	<< QPointF(12.5, 2.0)
	119	<< QPointF(15.0, 1.0)
	120	<< QPointF(17.5, 6.0)
	121	<< QPointF(20.0, 10.0);
	122	simpleRasterSeries->setUseOpenGL(false);
	123	simpleRasterSeries->setPen(QPen(QBrush("magenta"), 8));
	124	chart->addSeries(simpleRasterSeries);
	125	simpleRasterSeries->attachAxis(axisX);
	126	simpleRasterSeries->attachAxis(axisY);
	127
	128	QLineSeries *simpleGLSeries = new QLineSeries;
	129	simpleGLSeries->setUseOpenGL(true);
	130	simpleGLSeries->setPen(QPen(QBrush("black"), 2));
	131	simpleGLSeries->replace(simpleRasterSeries->points());
	132	chart->addSeries(simpleGLSeries);
	133	simpleGLSeries->attachAxis(axisX);
	134	simpleGLSeries->attachAxis(axisY);
	135	#endif
	136
	137	QChartView *chartView = new QChartView(chart);
	138
	139	QMainWindow window;
	140	window.setCentralWidget(chartView);
	141	window.resize(600, 400);
	142	window.show();
	143
	144	DataSource dataSource;
	145	dataSource.generateData(seriesCount, 10, pointCount);
	146
	147	QLabel *fpsLabel = new QLabel(&window);
	148	QLabel *countLabel = new QLabel(&window);
	149	QString countText = QStringLiteral("Total point count: %1");
	150	countLabel->setText(countText.arg(pointCount * seriesCount));
	151	countLabel->resize(window.width(), countLabel->height());
	152	fpsLabel->move(10,2);
	153	fpsLabel->raise();
	154	fpsLabel->show();
	155	countLabel->move(10, 14);
	156	fpsLabel->raise();
	157	countLabel->show();
	158
	159	// We can get more than one changed event per frame, so do async update.
	160	// This also allows the application to be responsive.
	161	QObject::connect(chart->scene(), &QGraphicsScene::changed,
	162	&dataSource, &DataSource::handleSceneChanged);
	163
	164	dataSource.startUpdates(seriesList, fpsLabel);
	165
	166	return a.exec();
	167	}

examples/charts/openglseries/openglseries.pro created 644 +9 0

@@ -0,0 +1,9
	1	!include( ../examples.pri ) {
	2	error( "Couldn't find the examples.pri file!" )
	3	}
	4
	5	TARGET = openglseries
	6	SOURCES += main.cpp \
	7	datasource.cpp
	8	HEADERS += datasource.h
	9

src/charts/doc/images/examples_openglseries.png created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

src/charts/doc/src/examples-openglseries.qdoc created 644 +37 0

@@ -0,0 +1,37
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	/*!
	20	\example openglseries
	21	\title OpenGL Accelerated Series Example
	22	\ingroup qtcharts_examples
	23
	24	\brief The example shows how to enable OpenGL acceleration for QLineSeries and QScatterSeries.
	25
	26	\image examples_openglseries.png
	27
	28	To create an OpenGL accelerated series, all you have to do compared to a regular
	29	series is to set QAbstractSeries::useOpenGL property to \c{true}:
	30
	31	\snippet openglseries/main.cpp 1
	32
	33	This makes the chart to instantiate a transparent QOpenGLWidget that is used to draw
	34	the accelerated series on top of the chart.
	35
	36	\note The OpenGL acceleration is only supported for QLineSeries and QScatterSeries.
	37	*/

src/charts/glwidget.cpp created 644 +222 0

@@ -0,0 +1,222
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#ifndef QT_NO_OPENGL
	20
	21	#include "private/glwidget_p.h"
	22	#include "private/glxyseriesdata_p.h"
	23	#include <QtGui/QOpenGLShaderProgram>
	24	#include <QtGui/QOpenGLContext>
	25	#include <QtGui/QOpenGLBuffer>
	26
	27	//#define QDEBUG_TRACE_GL_FPS
	28	#ifdef QDEBUG_TRACE_GL_FPS
	29	# include <QElapsedTimer>
	30	#endif
	31
	32	QT_CHARTS_BEGIN_NAMESPACE
	33
	34	GLWidget::GLWidget(GLXYSeriesDataManager xyDataManager, QWidget parent)
	35	: QOpenGLWidget(parent),
	36	m_program(0),
	37	m_shaderAttribLoc(-1),
	38	m_colorUniformLoc(-1),
	39	m_minUniformLoc(-1),
	40	m_deltaUniformLoc(-1),
	41	m_pointSizeUniformLoc(-1),
	42	m_xyDataManager(xyDataManager)
	43	{
	44	setAttribute(Qt::WA_TranslucentBackground);
	45	setAttribute(Qt::WA_AlwaysStackOnTop);
	46	setAttribute(Qt::WA_TransparentForMouseEvents);
	47
	48	QSurfaceFormat surfaceFormat;
	49	surfaceFormat.setDepthBufferSize(0);
	50	surfaceFormat.setStencilBufferSize(0);
	51	surfaceFormat.setRedBufferSize(8);
	52	surfaceFormat.setGreenBufferSize(8);
	53	surfaceFormat.setBlueBufferSize(8);
	54	surfaceFormat.setAlphaBufferSize(8);
	55	surfaceFormat.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
	56	surfaceFormat.setRenderableType(QSurfaceFormat::DefaultRenderableType);
	57	setFormat(surfaceFormat);
	58
	59	connect(xyDataManager, &GLXYSeriesDataManager::seriesRemoved,
	60	this, &GLWidget::cleanXYSeriesResources);
	61	}
	62
	63	GLWidget::~GLWidget()
	64	{
	65	cleanup();
	66	}
	67
	68	void GLWidget::cleanup()
	69	{
	70	makeCurrent();
	71
	72	delete m_program;
	73	m_program = 0;
	74
	75	foreach (QOpenGLBuffer *buffer, m_seriesBufferMap.values())
	76	delete buffer;
	77	m_seriesBufferMap.clear();
	78
	79	doneCurrent();
	80	}
	81
	82	void GLWidget::cleanXYSeriesResources(const QXYSeries *series)
	83	{
	84	makeCurrent();
	85	if (series) {
	86	delete m_seriesBufferMap.take(series);
	87	} else {
	88	// Null series means all series were removed
	89	foreach (QOpenGLBuffer *buffer, m_seriesBufferMap.values())
	90	delete buffer;
	91	m_seriesBufferMap.clear();
	92	}
	93	doneCurrent();
	94	}
	95
	96	static const char *vertexSource =
	97	"attribute highp vec2 points;\n"
	98	"uniform highp vec2 min;\n"
	99	"uniform highp vec2 delta;\n"
	100	"uniform highp float pointSize;\n"
	101	"void main() {\n"
	102	" vec2 normalPoint = vec2(-1, -1) + ((points - min) / delta);\n"
	103	" gl_Position = vec4(normalPoint, 0, 1);\n"
	104	" gl_PointSize = pointSize;\n"
	105	"}";
	106	static const char *fragmentSource =
	107	"uniform highp vec3 color;\n"
	108	"void main() {\n"
	109	" gl_FragColor = vec4(color,1);\n"
	110	"}\n";
	111
	112	void GLWidget::initializeGL()
	113	{
	114	connect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &GLWidget::cleanup);
	115
	116	initializeOpenGLFunctions();
	117	glClearColor(0, 0, 0, 0);
	118
	119	m_program = new QOpenGLShaderProgram;
	120	m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexSource);
	121	m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentSource);
	122	m_program->bindAttributeLocation("points", 0);
	123	m_program->link();
	124
	125	m_program->bind();
	126	m_colorUniformLoc = m_program->uniformLocation("color");
	127	m_minUniformLoc = m_program->uniformLocation("min");
	128	m_deltaUniformLoc = m_program->uniformLocation("delta");
	129	m_pointSizeUniformLoc = m_program->uniformLocation("pointSize");
	130
	131
	132	// Create a vertex array object. In OpenGL ES 2.0 and OpenGL 2.x
	133	// implementations this is optional and support may not be present
	134	// at all. Nonetheless the below code works in all cases and makes
	135	// sure there is a VAO when one is needed.
	136	m_vao.create();
	137	QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
	138
	139	glEnableVertexAttribArray(0);
	140
	141	glDisable(GL_DEPTH_TEST);
	142	glDisable(GL_STENCIL_TEST);
	143
	144	#if !defined(QT_OPENGL_ES_2)
	145	if (!QOpenGLContext::currentContext()->isOpenGLES()) {
	146	// Make it possible to change point primitive size and use textures with them in
	147	// the shaders. These are implicitly enabled in ES2.
	148	glEnable(GL_PROGRAM_POINT_SIZE);
	149	}
	150	#endif
	151
	152	m_program->release();
	153	}
	154
	155	void GLWidget::paintGL()
	156	{
	157	glClear(GL_COLOR_BUFFER_BIT);
	158
	159	QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
	160	m_program->bind();
	161
	162	GLXYDataMapIterator i(m_xyDataManager->dataMap());
	163	while (i.hasNext()) {
	164	i.next();
	165	QOpenGLBuffer *vbo = m_seriesBufferMap.value(i.key());
	166	GLXYSeriesData *data = i.value();
	167
	168	m_program->setUniformValue(m_colorUniformLoc, data->color);
	169	m_program->setUniformValue(m_minUniformLoc, data->min);
	170	m_program->setUniformValue(m_deltaUniformLoc, data->delta);
	171
	172	if (!vbo) {
	173	vbo = new QOpenGLBuffer;
	174	m_seriesBufferMap.insert(i.key(), vbo);
	175	vbo->create();
	176	}
	177	vbo->bind();
	178	if (data->dirty) {
	179	vbo->allocate(data->array.constData(), data->array.count() * sizeof(GLfloat));
	180	data->dirty = false;
	181	}
	182
	183	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
	184	if (data->type == QAbstractSeries::SeriesTypeLine) {
	185	glLineWidth(data->width);
	186	glDrawArrays(GL_LINE_STRIP, 0, data->array.size() / 2);
	187	} else { // Scatter
	188	m_program->setUniformValue(m_pointSizeUniformLoc, data->width);
	189	glDrawArrays(GL_POINTS, 0, data->array.size() / 2);
	190	}
	191	vbo->release();
	192	}
	193
	194	#ifdef QDEBUG_TRACE_GL_FPS
	195	static QElapsedTimer stopWatch;
	196	static int frameCount = -1;
	197	if (frameCount == -1) {
	198	stopWatch.start();
	199	frameCount = 0;
	200	}
	201	frameCount++;
	202	int elapsed = stopWatch.elapsed();
	203	if (elapsed >= 1000) {
	204	elapsed = stopWatch.restart();
	205	qreal fps = qreal(0.1 * int(10000.0 * (qreal(frameCount) / qreal(elapsed))));
	206	qDebug() << "FPS:" << fps;
	207	frameCount = 0;
	208	}
	209	#endif
	210
	211	m_program->release();
	212	}
	213
	214	void GLWidget::resizeGL(int w, int h)
	215	{
	216	Q_UNUSED(w)
	217	Q_UNUSED(h)
	218	}
	219
	220	QT_CHARTS_END_NAMESPACE
	221
	222	#endif

src/charts/glwidget_p.h created 644 +80 0

@@ -0,0 +1,80
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	// W A R N I N G
	20	// -------------
	21	//
	22	// This file is not part of the Qt Chart API. It exists purely as an
	23	// implementation detail. This header file may change from version to
	24	// version without notice, or even be removed.
	25	//
	26	// We mean it.
	27
	28	#ifndef GLWIDGET_H
	29	#define GLWIDGET_H
	30
	31	#ifndef QT_NO_OPENGL
	32
	33	#include <QtWidgets/QOpenGLWidget>
	34	#include <QtGui/QOpenGLFunctions>
	35	#include <QtGui/QOpenGLVertexArrayObject>
	36	#include <QtCore/QHash>
	37	#include <QtCharts/QAbstractSeries>
	38	#include <QtCharts/QXYSeries>
	39
	40	QT_FORWARD_DECLARE_CLASS(QOpenGLShaderProgram)
	41
	42	class QOpenGLBuffer;
	43
	44	QT_CHARTS_BEGIN_NAMESPACE
	45
	46	class GLXYSeriesDataManager;
	47
	48	class GLWidget : public QOpenGLWidget, protected QOpenGLFunctions
	49	{
	50	Q_OBJECT
	51
	52	public:
	53	GLWidget(GLXYSeriesDataManager xyDataManager, QWidget parent = 0);
	54	~GLWidget();
	55
	56	public Q_SLOTS:
	57	void cleanup();
	58	void cleanXYSeriesResources(const QXYSeries *series);
	59
	60	protected:
	61	void initializeGL() Q_DECL_OVERRIDE;
	62	void paintGL() Q_DECL_OVERRIDE;
	63	void resizeGL(int width, int height) Q_DECL_OVERRIDE;
	64
	65	private:
	66	QOpenGLShaderProgram *m_program;
	67	int m_shaderAttribLoc;
	68	int m_colorUniformLoc;
	69	int m_minUniformLoc;
	70	int m_deltaUniformLoc;
	71	int m_pointSizeUniformLoc;
	72	QOpenGLVertexArrayObject m_vao;
	73
	74	QHash<const QAbstractSeries , QOpenGLBuffer > m_seriesBufferMap;
	75	GLXYSeriesDataManager *m_xyDataManager;
	76	};
	77
	78	QT_CHARTS_END_NAMESPACE
	79	#endif
	80	#endif

src/charts/xychart/glxyseriesdata.cpp created 644 +147 0

@@ -0,0 +1,147
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#include "private/glxyseriesdata_p.h"
	20	#include "private/abstractdomain_p.h"
	21	#include <QtCharts/QScatterSeries>
	22
	23	QT_CHARTS_BEGIN_NAMESPACE
	24
	25	GLXYSeriesDataManager::GLXYSeriesDataManager(QObject *parent)
	26	: QObject(parent),
	27	m_mapDirty(false)
	28	{
	29	}
	30
	31	GLXYSeriesDataManager::~GLXYSeriesDataManager()
	32	{
	33	cleanup();
	34	}
	35
	36	void GLXYSeriesDataManager::setPoints(QXYSeries series, const AbstractDomain domain)
	37	{
	38	GLXYSeriesData *data = m_seriesDataMap.value(series);
	39	if (!data) {
	40	data = new GLXYSeriesData;
	41	data->type = series->type();
	42	QColor sc;
	43	if (data->type == QAbstractSeries::SeriesTypeScatter) {
	44	QScatterSeries scatter = static_cast<QScatterSeries >(series);
	45	data->width = float(scatter->markerSize());
	46	sc = scatter->color(); // Scatter overwrites color property
	47	} else {
	48	data->width = float(series->pen().widthF());
	49	sc = series->color();
	50	}
	51	data->color = QVector3D(float(sc.redF()), float(sc.greenF()), float(sc.blueF()));
	52	connect(series, &QXYSeries::penChanged, this,
	53	&GLXYSeriesDataManager::handleSeriesPenChange);
	54	connect(series, &QXYSeries::useOpenGLChanged, this,
	55	&GLXYSeriesDataManager::handleSeriesOpenGLChange);
	56	m_seriesDataMap.insert(series, data);
	57	m_mapDirty = true;
	58	}
	59	QVector<float> &array = data->array;
	60
	61	bool logAxis = false;
	62	foreach (QAbstractAxis* axis, series->attachedAxes()) {
	63	if (axis->type() == QAbstractAxis::AxisTypeLogValue) {
	64	logAxis = true;
	65	break;
	66	}
	67	}
	68
	69	int count = series->count();
	70	int index = 0;
	71	array.resize(count * 2);
	72	if (logAxis) {
	73	// Use domain to resolve geometry points. Not as fast as shaders, but simpler that way
	74	QVector<QPointF> geometryPoints = domain->calculateGeometryPoints(series->pointsVector());
	75	const float height = domain->size().height();
	76	if (geometryPoints.size()) {
	77	for (int i = 0; i < count; i++) {
	78	const QPointF &point = geometryPoints.at(i);
	79	array[index++] = float(point.x());
	80	array[index++] = float(height - point.y());
	81	}
	82	} else {
	83	// If there are invalid log values, geometry points generation fails
	84	for (int i = 0; i < count; i++) {
	85	array[index++] = 0.0f;
	86	array[index++] = 0.0f;
	87	}
	88	}
	89	data->min = QVector2D(0, 0);
	90	data->delta = QVector2D(domain->size().width() / 2.0f, domain->size().height() / 2.0f);
	91	} else {
	92	// Regular value axes, so we can do the math easily on shaders.
	93	QVector<QPointF> seriesPoints = series->pointsVector();
	94	for (int i = 0; i < count; i++) {
	95	const QPointF &point = seriesPoints.at(i);
	96	array[index++] = float(point.x());
	97	array[index++] = float(point.y());
	98	}
	99	data->min = QVector2D(domain->minX(), domain->minY());
	100	data->delta = QVector2D((domain->maxX() - domain->minX()) / 2.0f,
	101	(domain->maxY() - domain->minY()) / 2.0f);
	102	}
	103	data->dirty = true;
	104	}
	105
	106	void GLXYSeriesDataManager::removeSeries(const QXYSeries *series)
	107	{
	108	GLXYSeriesData *data = m_seriesDataMap.take(series);
	109	if (data) {
	110	disconnect(series, 0, this, 0);
	111	delete data;
	112	emit seriesRemoved(series);
	113	m_mapDirty = true;
	114	}
	115	}
	116
	117	void GLXYSeriesDataManager::cleanup()
	118	{
	119	foreach (GLXYSeriesData *data, m_seriesDataMap.values())
	120	delete data;
	121	m_seriesDataMap.clear();
	122	m_mapDirty = true;
	123	// Signal all series removal by using zero as parameter
	124	emit seriesRemoved(0);
	125	}
	126
	127	void GLXYSeriesDataManager::handleSeriesPenChange()
	128	{
	129	QXYSeries series = qobject_cast<QXYSeries >(sender());
	130	if (series) {
	131	GLXYSeriesData *data = m_seriesDataMap.value(series);
	132	if (data) {
	133	QColor sc = series->color();
	134	data->color = QVector3D(float(sc.redF()), float(sc.greenF()), float(sc.blueF()));
	135	data->width = float(series->pen().widthF());
	136	}
	137	}
	138	}
	139
	140	void GLXYSeriesDataManager::handleSeriesOpenGLChange()
	141	{
	142	QXYSeries series = qobject_cast<QXYSeries >(sender());
	143	if (!series->useOpenGL())
	144	removeSeries(series);
	145	}
	146
	147	QT_CHARTS_END_NAMESPACE

src/charts/xychart/glxyseriesdata_p.h created 644 +91 0

@@ -0,0 +1,91
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	// W A R N I N G
	20	// -------------
	21	//
	22	// This file is not part of the Qt Chart API. It exists purely as an
	23	// implementation detail. This header file may change from version to
	24	// version without notice, or even be removed.
	25	//
	26	// We mean it.
	27
	28	#ifndef GLXYSERIESDATA_H
	29	#define GLXYSERIESDATA_H
	30
	31	#include <QtCore/QMap>
	32	#include <QtCharts/QAbstractSeries>
	33	#include <QtCharts/QXYSeries>
	34	#include <QtGui/QVector3D>
	35	#include <QtGui/QVector2D>
	36
	37	QT_CHARTS_BEGIN_NAMESPACE
	38
	39	class AbstractDomain;
	40
	41	struct GLXYSeriesData {
	42	QVector<float> array;
	43	bool dirty;
	44	QVector3D color;
	45	float width;
	46	QAbstractSeries::SeriesType type;
	47	QVector2D min;
	48	QVector2D delta;
	49	};
	50
	51	typedef QMap<const QXYSeries , GLXYSeriesData > GLXYDataMap;
	52	typedef QMapIterator<const QXYSeries , GLXYSeriesData > GLXYDataMapIterator;
	53
	54	class GLXYSeriesDataManager : public QObject
	55	{
	56	Q_OBJECT
	57
	58	public:
	59	GLXYSeriesDataManager(QObject *parent = 0);
	60	~GLXYSeriesDataManager();
	61
	62	void setPoints(QXYSeries series, const AbstractDomain domain);
	63
	64	void removeSeries(const QXYSeries *series);
	65
	66	GLXYDataMap &dataMap() { return m_seriesDataMap; }
	67
	68	// These functions are needed by qml side, so they must be inline
	69	bool mapDirty() const { return m_mapDirty; }
	70	void clearAllDirty() {
	71	m_mapDirty = false;
	72	foreach (GLXYSeriesData *data, m_seriesDataMap.values())
	73	data->dirty = false;
	74	}
	75
	76	public Q_SLOTS:
	77	void cleanup();
	78	void handleSeriesPenChange();
	79	void handleSeriesOpenGLChange();
	80
	81	Q_SIGNALS:
	82	void seriesRemoved(const QXYSeries *series);
	83
	84	private:
	85	GLXYDataMap m_seriesDataMap;
	86	bool m_mapDirty;
	87	};
	88
	89	QT_CHARTS_END_NAMESPACE
	90
	91	#endif

src/chartsqml2/declarativechartnode.cpp created 644 +78 0

@@ -0,0 +1,78
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#include "declarativechartnode.h"
	20	#include "declarativerendernode.h"
	21	#include <QtGui/QOpenGLContext>
	22	#include <QtGui/QOpenGLFunctions>
	23	#include <QtGui/QOpenGLFramebufferObjectFormat>
	24	#include <QtGui/QOpenGLFramebufferObject>
	25	#include <QOpenGLShaderProgram>
	26	#include <QtGui/QOpenGLBuffer>
	27
	28	QT_CHARTS_BEGIN_NAMESPACE
	29
	30	// This node handles displaying of the chart itself
	31	DeclarativeChartNode::DeclarativeChartNode(QQuickWindow *window) :
	32	QSGSimpleTextureNode(),
	33	m_texture(0),
	34	m_window(window),
	35	m_textureOptions(0),
	36	m_textureSize(1, 1),
	37	m_glRenderNode(0)
	38	{
	39	initializeOpenGLFunctions();
	40
	41	// Our texture node must have a texture, so use a default one pixel texture
	42	GLuint defaultTexture = 0;
	43	glGenTextures(1, &defaultTexture);
	44	glBindTexture(GL_TEXTURE_2D, defaultTexture);
	45	uchar buf[4] = { 0, 0, 0, 0 };
	46	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &buf);
	47
	48	QQuickWindow::CreateTextureOptions defaultTextureOptions = QQuickWindow::CreateTextureOptions(
	49	QQuickWindow::TextureHasAlphaChannel \| QQuickWindow::TextureOwnsGLTexture);
	50	m_texture = m_window->createTextureFromId(defaultTexture, QSize(1, 1), defaultTextureOptions);
	51
	52	setTexture(m_texture);
	53	setFiltering(QSGTexture::Linear);
	54
	55	// Create child node for rendering GL graphics
	56	m_glRenderNode = new DeclarativeRenderNode(m_window);
	57	m_glRenderNode->setFlag(OwnedByParent);
	58	appendChildNode(m_glRenderNode);
	59	m_glRenderNode->setRect(0, 0, 0, 0); // Hide child node by default
	60	}
	61
	62	DeclarativeChartNode::~DeclarativeChartNode()
	63	{
	64	delete m_texture;
	65	}
	66
	67	// Must be called on render thread and in context
	68	void DeclarativeChartNode::createTextureFromImage(const QImage &chartImage)
	69	{
	70	if (chartImage.size() != m_textureSize)
	71	m_textureSize = chartImage.size();
	72
	73	delete m_texture;
	74	m_texture = m_window->createTextureFromImage(chartImage, m_textureOptions);
	75	setTexture(m_texture);
	76	}
	77
	78	QT_CHARTS_END_NAMESPACE

src/chartsqml2/declarativechartnode.h created 644 +50 0

@@ -0,0 +1,50
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#ifndef DECLARATIVECHARTNODE_P_H
	20	#define DECLARATIVECHARTNODE_P_H
	21
	22	#include <QtCharts/QChartGlobal>
	23	#include <QtQuick/QSGSimpleTextureNode>
	24	#include <QtQuick/QQuickWindow>
	25	#include <QtGui/QOpenGLFunctions>
	26
	27	QT_CHARTS_BEGIN_NAMESPACE
	28
	29	class DeclarativeRenderNode;
	30
	31	class DeclarativeChartNode : public QSGSimpleTextureNode, QOpenGLFunctions
	32	{
	33	public:
	34	DeclarativeChartNode(QQuickWindow *window);
	35	~DeclarativeChartNode();
	36
	37	void createTextureFromImage(const QImage &chartImage);
	38	DeclarativeRenderNode *glRenderNode() const { return m_glRenderNode; }
	39
	40	private:
	41	QSGTexture *m_texture;
	42	QQuickWindow *m_window;
	43	QQuickWindow::CreateTextureOptions m_textureOptions;
	44	QSize m_textureSize;
	45	DeclarativeRenderNode *m_glRenderNode;
	46	};
	47
	48	QT_CHARTS_END_NAMESPACE
	49
	50	#endif // DECLARATIVECHARTNODE_P_H

src/chartsqml2/declarativerendernode.cpp created 644 +317 0

@@ -0,0 +1,317
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#include "declarativerendernode.h"
	20
	21	#include <QtGui/QOpenGLContext>
	22	#include <QtGui/QOpenGLFunctions>
	23	#include <QtGui/QOpenGLFramebufferObjectFormat>
	24	#include <QtGui/QOpenGLFramebufferObject>
	25	#include <QOpenGLShaderProgram>
	26	#include <QtGui/QOpenGLBuffer>
	27
	28	//#define QDEBUG_TRACE_GL_FPS
	29	#ifdef QDEBUG_TRACE_GL_FPS
	30	# include <QElapsedTimer>
	31	#endif
	32
	33	QT_CHARTS_BEGIN_NAMESPACE
	34
	35	// This node draws the xy series data on a transparent background using OpenGL.
	36	// It is used as a child node of the chart node.
	37	DeclarativeRenderNode::DeclarativeRenderNode(QQuickWindow *window) :
	38	QObject(),
	39	QSGSimpleTextureNode(),
	40	m_texture(0),
	41	m_window(window),
	42	m_textureOptions(QQuickWindow::TextureHasAlphaChannel),
	43	m_textureSize(1, 1),
	44	m_recreateFbo(false),
	45	m_fbo(0),
	46	m_program(0),
	47	m_shaderAttribLoc(-1),
	48	m_colorUniformLoc(-1),
	49	m_minUniformLoc(-1),
	50	m_deltaUniformLoc(-1),
	51	m_pointSizeUniformLoc(-1),
	52	m_renderNeeded(true)
	53	{
	54	initializeOpenGLFunctions();
	55
	56	// Our texture node must have a texture, so use a default one pixel texture
	57	GLuint defaultTexture = 0;
	58	glGenTextures(1, &defaultTexture);
	59	glBindTexture(GL_TEXTURE_2D, defaultTexture);
	60	uchar buf[4] = { 0, 0, 0, 0 };
	61	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &buf);
	62
	63	QQuickWindow::CreateTextureOptions defaultTextureOptions = QQuickWindow::CreateTextureOptions(
	64	QQuickWindow::TextureHasAlphaChannel \| QQuickWindow::TextureOwnsGLTexture);
	65	m_texture = m_window->createTextureFromId(defaultTexture, QSize(1, 1), defaultTextureOptions);
	66
	67	setTexture(m_texture);
	68	setFiltering(QSGTexture::Linear);
	69	setTextureCoordinatesTransform(QSGSimpleTextureNode::MirrorVertically);
	70	}
	71
	72	DeclarativeRenderNode::~DeclarativeRenderNode()
	73	{
	74	delete m_texture;
	75	delete m_fbo;
	76
	77	delete m_program;
	78	m_program = 0;
	79
	80	cleanXYSeriesResources(0);
	81	}
	82
	83	static const char *vertexSource =
	84	"attribute highp vec2 points;\n"
	85	"uniform highp vec2 min;\n"
	86	"uniform highp vec2 delta;\n"
	87	"uniform highp float pointSize;\n"
	88	"void main() {\n"
	89	" vec2 normalPoint = vec2(-1, -1) + ((points - min) / delta);\n"
	90	" gl_Position = vec4(normalPoint, 0, 1);\n"
	91	" gl_PointSize = pointSize;\n"
	92	"}";
	93	static const char *fragmentSource =
	94	"uniform highp vec3 color;\n"
	95	"void main() {\n"
	96	" gl_FragColor = vec4(color,1);\n"
	97	"}\n";
	98
	99	// Must be called on render thread and in context
	100	void DeclarativeRenderNode::initGL()
	101	{
	102	recreateFBO();
	103
	104	m_program = new QOpenGLShaderProgram;
	105	m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexSource);
	106	m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentSource);
	107	m_program->bindAttributeLocation("points", 0);
	108	m_program->link();
	109
	110	m_program->bind();
	111	m_colorUniformLoc = m_program->uniformLocation("color");
	112	m_minUniformLoc = m_program->uniformLocation("min");
	113	m_deltaUniformLoc = m_program->uniformLocation("delta");
	114	m_pointSizeUniformLoc = m_program->uniformLocation("pointSize");
	115
	116	// Create a vertex array object. In OpenGL ES 2.0 and OpenGL 2.x
	117	// implementations this is optional and support may not be present
	118	// at all. Nonetheless the below code works in all cases and makes
	119	// sure there is a VAO when one is needed.
	120	m_vao.create();
	121	QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
	122
	123	#if !defined(QT_OPENGL_ES_2)
	124	if (!QOpenGLContext::currentContext()->isOpenGLES()) {
	125	// Make it possible to change point primitive size and use textures with them in
	126	// the shaders. These are implicitly enabled in ES2.
	127	// Qt Quick doesn't change these flags, so it should be safe to just enable them
	128	// at initialization.
	129	glEnable(GL_PROGRAM_POINT_SIZE);
	130	}
	131	#endif
	132
	133	m_program->release();
	134	}
	135
	136	void DeclarativeRenderNode::recreateFBO()
	137	{
	138	QOpenGLFramebufferObjectFormat fboFormat;
	139	fboFormat.setAttachment(QOpenGLFramebufferObject::NoAttachment);
	140	delete m_fbo;
	141	m_fbo = new QOpenGLFramebufferObject(m_textureSize.width(),
	142	m_textureSize.height(),
	143	fboFormat);
	144
	145	delete m_texture;
	146	m_texture = m_window->createTextureFromId(m_fbo->texture(), m_textureSize, m_textureOptions);
	147	setTexture(m_texture);
	148
	149	m_recreateFbo = false;
	150	}
	151
	152	// Must be called on render thread and in context
	153	void DeclarativeRenderNode::setTextureSize(const QSize &size)
	154	{
	155	m_textureSize = size;
	156	m_recreateFbo = true;
	157	m_renderNeeded = true;
	158	}
	159
	160	// Must be called on render thread while gui thread is blocked, and in context
	161	void DeclarativeRenderNode::setSeriesData(bool mapDirty, const GLXYDataMap &dataMap)
	162	{
	163	if (mapDirty) {
	164	// Series have changed, recreate map, but utilize old data where feasible
	165	GLXYDataMap oldMap = m_xyDataMap;
	166	m_xyDataMap.clear();
	167
	168	GLXYDataMapIterator i(dataMap);
	169	while (i.hasNext()) {
	170	i.next();
	171	GLXYSeriesData *data = oldMap.take(i.key());
	172	const GLXYSeriesData *newData = i.value();
	173	if (!data \|\| newData->dirty) {
	174	data = new GLXYSeriesData;
	175	data->array = newData->array;
	176	data->color = newData->color;
	177	data->dirty = newData->dirty;
	178	data->width = newData->width;
	179	data->type = newData->type;
	180	data->min = newData->min;
	181	data->delta = newData->delta;
	182	}
	183	m_xyDataMap.insert(i.key(), data);
	184	}
	185	// Delete remaining old data
	186	i = oldMap;
	187	while (i.hasNext()) {
	188	i.next();
	189	delete i.value();
	190	cleanXYSeriesResources(i.key());
	191	}
	192	} else {
	193	// Series have not changed, so just copy dirty data over
	194	GLXYDataMapIterator i(dataMap);
	195	while (i.hasNext()) {
	196	i.next();
	197	const GLXYSeriesData *newData = i.value();
	198	if (i.value()->dirty) {
	199	GLXYSeriesData *data = m_xyDataMap.value(i.key());
	200	if (data) {
	201	data->array = newData->array;
	202	data->color = newData->color;
	203	data->dirty = newData->dirty;
	204	data->width = newData->width;
	205	data->type = newData->type;
	206	data->min = newData->min;
	207	data->delta = newData->delta;
	208	}
	209	}
	210	}
	211	}
	212	markDirty(DirtyMaterial);
	213	m_renderNeeded = true;
	214	}
	215
	216	void DeclarativeRenderNode::renderGL()
	217	{
	218	glClearColor(0, 0, 0, 0);
	219
	220	QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
	221	m_program->bind();
	222	m_fbo->bind();
	223
	224	glClear(GL_COLOR_BUFFER_BIT);
	225	glEnableVertexAttribArray(0);
	226
	227	glViewport(0, 0, m_textureSize.width(), m_textureSize.height());
	228
	229	GLXYDataMapIterator i(m_xyDataMap);
	230	while (i.hasNext()) {
	231	i.next();
	232	QOpenGLBuffer *vbo = m_seriesBufferMap.value(i.key());
	233	GLXYSeriesData *data = i.value();
	234
	235	m_program->setUniformValue(m_colorUniformLoc, data->color);
	236	m_program->setUniformValue(m_minUniformLoc, data->min);
	237	m_program->setUniformValue(m_deltaUniformLoc, data->delta);
	238
	239	if (!vbo) {
	240	vbo = new QOpenGLBuffer;
	241	m_seriesBufferMap.insert(i.key(), vbo);
	242	vbo->create();
	243	}
	244	vbo->bind();
	245	if (data->dirty) {
	246	vbo->allocate(data->array.constData(), data->array.count() * sizeof(GLfloat));
	247	data->dirty = false;
	248	}
	249
	250	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
	251	if (data->type == QAbstractSeries::SeriesTypeLine) {
	252	glLineWidth(data->width);
	253	glDrawArrays(GL_LINE_STRIP, 0, data->array.size() / 2);
	254	} else { // Scatter
	255	m_program->setUniformValue(m_pointSizeUniformLoc, data->width);
	256	glDrawArrays(GL_POINTS, 0, data->array.size() / 2);
	257	}
	258	vbo->release();
	259	}
	260
	261	#ifdef QDEBUG_TRACE_GL_FPS
	262	static QElapsedTimer stopWatch;
	263	static int frameCount = -1;
	264	if (frameCount == -1) {
	265	stopWatch.start();
	266	frameCount = 0;
	267	}
	268	frameCount++;
	269	int elapsed = stopWatch.elapsed();
	270	if (elapsed >= 1000) {
	271	elapsed = stopWatch.restart();
	272	qreal fps = qreal(0.1 * int(10000.0 * (qreal(frameCount) / qreal(elapsed))));
	273	qDebug() << "FPS:" << fps;
	274	frameCount = 0;
	275	}
	276	#endif
	277
	278	markDirty(DirtyMaterial);
	279	m_window->resetOpenGLState();
	280	}
	281
	282	// Must be called on render thread as response to beforeRendering signal
	283	void DeclarativeRenderNode::render()
	284	{
	285	if (m_renderNeeded) {
	286	if (m_xyDataMap.size()) {
	287	if (!m_program)
	288	initGL();
	289	if (m_recreateFbo)
	290	recreateFBO();
	291	renderGL();
	292	} else {
	293	if (rect() != QRectF()) {
	294	glClearColor(0, 0, 0, 0);
	295	m_fbo->bind();
	296	glClear(GL_COLOR_BUFFER_BIT);
	297
	298	// If last series was removed, zero out the node rect
	299	setRect(QRectF());
	300	}
	301	}
	302	m_renderNeeded = false;
	303	}
	304	}
	305
	306	void DeclarativeRenderNode::cleanXYSeriesResources(const QXYSeries *series)
	307	{
	308	if (series) {
	309	delete m_seriesBufferMap.take(series);
	310	} else {
	311	foreach (QOpenGLBuffer *buffer, m_seriesBufferMap.values())
	312	delete buffer;
	313	m_seriesBufferMap.clear();
	314	}
	315	}
	316
	317	QT_CHARTS_END_NAMESPACE

src/chartsqml2/declarativerendernode.h created 644 +74 0

@@ -0,0 +1,74
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#ifndef DECLARATIVERENDERNODE_P_H
	20	#define DECLARATIVERENDERNODE_P_H
	21
	22	#include <QtCharts/QChartGlobal>
	23	#include <private/glxyseriesdata_p.h>
	24	#include <QtQuick/QSGSimpleTextureNode>
	25	#include <QtQuick/QQuickWindow>
	26	#include <QtGui/QOpenGLVertexArrayObject>
	27	#include <QtGui/QOpenGLFunctions>
	28
	29	class QOpenGLFramebufferObject;
	30	class QOpenGLBuffer;
	31
	32	QT_CHARTS_BEGIN_NAMESPACE
	33
	34	class DeclarativeRenderNode : public QObject, public QSGSimpleTextureNode, QOpenGLFunctions
	35	{
	36	Q_OBJECT
	37	public:
	38	DeclarativeRenderNode(QQuickWindow *window);
	39	~DeclarativeRenderNode();
	40
	41	void initGL();
	42	QSize textureSize() const { return m_textureSize; }
	43	void setTextureSize(const QSize &size);
	44	void setSeriesData(bool mapDirty, const GLXYDataMap &dataMap);
	45
	46	public Q_SLOTS:
	47	void render();
	48
	49	private:
	50	void renderGL();
	51	void recreateFBO();
	52	void cleanXYSeriesResources(const QXYSeries *series);
	53
	54	QSGTexture *m_texture;
	55	QQuickWindow *m_window;
	56	QQuickWindow::CreateTextureOptions m_textureOptions;
	57	QSize m_textureSize;
	58	bool m_recreateFbo;
	59	GLXYDataMap m_xyDataMap;
	60	QOpenGLFramebufferObject *m_fbo;
	61	QOpenGLShaderProgram *m_program;
	62	int m_shaderAttribLoc;
	63	int m_colorUniformLoc;
	64	int m_minUniformLoc;
	65	int m_deltaUniformLoc;
	66	int m_pointSizeUniformLoc;
	67	QOpenGLVertexArrayObject m_vao;
	68	QHash<const QAbstractSeries , QOpenGLBuffer > m_seriesBufferMap;
	69	bool m_renderNeeded;
	70	};
	71
	72	QT_CHARTS_END_NAMESPACE
	73
	74	#endif // DECLARATIVERENDERNODE_P_H

examples/charts/audio/xyseriesiodevice.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include "xyseriesiodevice.h"
             #include <QtCharts/QXYSeries>
             XYSeriesIODevice::XYSeriesIODevice(QXYSeries * series, QObject *parent) :
                 QIODevice(parent),
                 m_series(series)
             {
             }
             qint64 XYSeriesIODevice::readData(char * data, qint64 maxSize)
             {
                 Q_UNUSED(data)
                 Q_UNUSED(maxSize)
                 return -1;
             }
             qint64 XYSeriesIODevice::writeData(const char * data, qint64 maxSize)
             {
                 qint64 range = 2000;
-                QList<QPointF> oldPoints = m_series->points();
+                QVector<QPointF> oldPoints = m_series->pointsVector();
-                QList<QPointF> points;
+                QVector<QPointF> points;
                 int resolution = 4;
                 if (oldPoints.count() < range) {
-                    points = m_series->points();
+                    points = m_series->pointsVector();
                 } else {
                     for (int i = maxSize/resolution; i < oldPoints.count(); i++)
                         points.append(QPointF(i - maxSize/resolution, oldPoints.at(i).y()));
                 }
                 qint64 size = points.count();
                 for (int k = 0; k < maxSize/resolution; k++)
                     points.append(QPointF(k + size, ((quint8)data[resolution * k] - 128)/128.0));
                 m_series->replace(points);
                 return maxSize;
             }

examples/charts/charts.pro +7 -1

             TEMPLATE = subdirs
             SUBDIRS += areachart \
                        customchart \
                        linechart \
                        percentbarchart \
                        piechart \
                        piechartdrilldown \
                        scatterchart \
                        scatterinteractions \
                        splinechart \
                        stackedbarchart \
                        stackedbarchartdrilldown \
                        zoomlinechart \
                        modeldata \
                        barchart \
                        boxplotchart \
                        legend \
                        barmodelmapper \
                        lineandbar \
                        horizontalbarchart \
                        horizontalstackedbarchart \
                        horizontalpercentbarchart \
                        donutbreakdown \
                        temperaturerecords \
                        donutchart \
                        multiaxis \
                        legendmarkers \
                        logvalueaxis \
                        polarchart \
                        piechartcustomization \
                        dynamicspline \
                        nesteddonuts \
                        chartinteractions \
                        callout \
                        chartthemes
             qtHaveModule(quick) {
                 SUBDIRS += qmlboxplot \
                        qmlpiechart \
                        qmlweather \
                        qmlf1legends \
                        qmlcustomizations \
                        qmlaxes \
                        qmlcustomlegend \
                        qmlpolarchart \
                        qmlchart \
                        qmloscilloscope
             }
             qtHaveModule(multimedia) {
                 SUBDIRS += audio
             } else {
-                message("QtMultimedia library not available. Some examples are disabled")
+                message("QtMultimedia library not available. Some examples are disabled.")
+            }
+            contains(QT_CONFIG, opengl) {
+                SUBDIRS += openglseries
+            } else {
+                message("OpenGL not available. Some examples are disabled.")
             }
             !linux-arm*: {
             SUBDIRS += \
                 datetimeaxis
             }

examples/charts/chartthemes/themewidget.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include "themewidget.h"
             #include <QtCharts/QChartView>
             #include <QtCharts/QPieSeries>
             #include <QtCharts/QPieSlice>
             #include <QtCharts/QAbstractBarSeries>
             #include <QtCharts/QPercentBarSeries>
             #include <QtCharts/QStackedBarSeries>
             #include <QtCharts/QBarSeries>
             #include <QtCharts/QBarSet>
             #include <QtCharts/QLineSeries>
             #include <QtCharts/QSplineSeries>
             #include <QtCharts/QScatterSeries>
             #include <QtCharts/QAreaSeries>
             #include <QtCharts/QLegend>
             #include <QtWidgets/QGridLayout>
             #include <QtWidgets/QFormLayout>
             #include <QtWidgets/QComboBox>
             #include <QtWidgets/QSpinBox>
             #include <QtWidgets/QCheckBox>
             #include <QtWidgets/QGroupBox>
             #include <QtWidgets/QLabel>
             #include <QtCore/QTime>
             #include <QtCharts/QBarCategoryAxis>
             ThemeWidget::ThemeWidget(QWidget *parent) :
                 QWidget(parent),
                 m_listCount(3),
                 m_valueMax(10),
                 m_valueCount(7),
                 m_dataTable(generateRandomData(m_listCount, m_valueMax, m_valueCount)),
                 m_themeComboBox(createThemeBox()),
                 m_antialiasCheckBox(new QCheckBox("Anti-aliasing")),
                 m_animatedComboBox(createAnimationBox()),
                 m_legendComboBox(createLegendBox())
             {
                 connectSignals();
                 // create layout
                 QGridLayout *baseLayout = new QGridLayout();
                 QHBoxLayout *settingsLayout = new QHBoxLayout();
                 settingsLayout->addWidget(new QLabel("Theme:"));
                 settingsLayout->addWidget(m_themeComboBox);
                 settingsLayout->addWidget(new QLabel("Animation:"));
                 settingsLayout->addWidget(m_animatedComboBox);
                 settingsLayout->addWidget(new QLabel("Legend:"));
                 settingsLayout->addWidget(m_legendComboBox);
                 settingsLayout->addWidget(m_antialiasCheckBox);
                 settingsLayout->addStretch();
                 baseLayout->addLayout(settingsLayout, 0, 0, 1, 3);
                 //create charts
                 QChartView *chartView;
                 chartView = new QChartView(createAreaChart());
                 baseLayout->addWidget(chartView, 1, 0);
                 m_charts << chartView;
                 chartView = new QChartView(createBarChart(m_valueCount));
                 baseLayout->addWidget(chartView, 1, 1);
                 m_charts << chartView;
                 chartView = new QChartView(createLineChart());
                 baseLayout->addWidget(chartView, 1, 2);
                 m_charts << chartView;
                 chartView = new QChartView(createPieChart());
                 chartView->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored); // funny things happen if the pie slice labels no not fit the screen...
                 baseLayout->addWidget(chartView, 2, 0);
                 m_charts << chartView;
                 chartView = new QChartView(createSplineChart());
                 baseLayout->addWidget(chartView, 2, 1);
                 m_charts << chartView;
                 chartView = new QChartView(createScatterChart());
                 baseLayout->addWidget(chartView, 2, 2);
                 m_charts << chartView;
                 setLayout(baseLayout);
                 // Set defaults
                 m_antialiasCheckBox->setChecked(true);
                 updateUI();
             }
             ThemeWidget::~ThemeWidget()
             {
             }
             void ThemeWidget::connectSignals()
             {
                 connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 connect(m_antialiasCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 connect(m_animatedComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 connect(m_legendComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
             }
             DataTable ThemeWidget::generateRandomData(int listCount, int valueMax, int valueCount) const
             {
                 DataTable dataTable;
                 // set seed for random stuff
                 qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
                 // generate random data
                 for (int i(0); i < listCount; i++) {
                     DataList dataList;
                     qreal yValue(0);
                     for (int j(0); j < valueCount; j++) {
                         yValue = yValue + (qreal)(qrand() % valueMax) / (qreal) valueCount;
                         QPointF value((j + (qreal) rand() / (qreal) RAND_MAX) * ((qreal) m_valueMax / (qreal) valueCount),
                                       yValue);
                         QString label = "Slice " + QString::number(i) + ":" + QString::number(j);
                         dataList << Data(value, label);
                     }
                     dataTable << dataList;
                 }
                 return dataTable;
             }
             QComboBox *ThemeWidget::createThemeBox() const
             {
                 // settings layout
                 QComboBox *themeComboBox = new QComboBox();
                 themeComboBox->addItem("Light", QChart::ChartThemeLight);
                 themeComboBox->addItem("Blue Cerulean", QChart::ChartThemeBlueCerulean);
                 themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                 themeComboBox->addItem("Brown Sand", QChart::ChartThemeBrownSand);
                 themeComboBox->addItem("Blue NCS", QChart::ChartThemeBlueNcs);
                 themeComboBox->addItem("High Contrast", QChart::ChartThemeHighContrast);
                 themeComboBox->addItem("Blue Icy", QChart::ChartThemeBlueIcy);
                 themeComboBox->addItem("Qt", QChart::ChartThemeQt);
                 return themeComboBox;
             }
             QComboBox *ThemeWidget::createAnimationBox() const
             {
                 // settings layout
                 QComboBox *animationComboBox = new QComboBox();
                 animationComboBox->addItem("No Animations", QChart::NoAnimation);
                 animationComboBox->addItem("GridAxis Animations", QChart::GridAxisAnimations);
                 animationComboBox->addItem("Series Animations", QChart::SeriesAnimations);
                 animationComboBox->addItem("All Animations", QChart::AllAnimations);
                 return animationComboBox;
             }
             QComboBox *ThemeWidget::createLegendBox() const
             {
                 QComboBox *legendComboBox = new QComboBox();
                 legendComboBox->addItem("No Legend ", 0);
                 legendComboBox->addItem("Legend Top", Qt::AlignTop);
                 legendComboBox->addItem("Legend Bottom", Qt::AlignBottom);
                 legendComboBox->addItem("Legend Left", Qt::AlignLeft);
                 legendComboBox->addItem("Legend Right", Qt::AlignRight);
                 return legendComboBox;
             }
             QChart *ThemeWidget::createAreaChart() const
             {
                 QChart *chart = new QChart();
                 chart->setTitle("Area chart");
                 // The lower series initialized to zero values
                 QLineSeries *lowerSeries = 0;
                 QString name("Series ");
                 int nameIndex = 0;
                 for (int i(0); i < m_dataTable.count(); i++) {
                     QLineSeries *upperSeries = new QLineSeries(chart);
                     for (int j(0); j < m_dataTable[i].count(); j++) {
                         Data data = m_dataTable[i].at(j);
                         if (lowerSeries) {
-                            const QList<QPointF>& points = lowerSeries->points();
+                            const QVector<QPointF>& points = lowerSeries->pointsVector();
                             upperSeries->append(QPointF(j, points[i].y() + data.first.y()));
                         } else {
                             upperSeries->append(QPointF(j, data.first.y()));
                         }
                     }
                     QAreaSeries *area = new QAreaSeries(upperSeries, lowerSeries);
                     area->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(area);
                     chart->createDefaultAxes();
                     lowerSeries = upperSeries;
                 }
                 return chart;
             }
             QChart *ThemeWidget::createBarChart(int valueCount) const
             {
                 Q_UNUSED(valueCount);
                 QChart *chart = new QChart();
                 chart->setTitle("Bar chart");
                 QStackedBarSeries *series = new QStackedBarSeries(chart);
                 for (int i(0); i < m_dataTable.count(); i++) {
                     QBarSet *set = new QBarSet("Bar set " + QString::number(i));
                     foreach (Data data, m_dataTable[i])
                         *set << data.first.y();
                     series->append(set);
                 }
                 chart->addSeries(series);
                 chart->createDefaultAxes();
                 return chart;
             }
             QChart *ThemeWidget::createLineChart() const
             {
                 QChart *chart = new QChart();
                 chart->setTitle("Line chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QLineSeries *series = new QLineSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 chart->createDefaultAxes();
                 return chart;
             }
             QChart *ThemeWidget::createPieChart() const
             {
                 QChart *chart = new QChart();
                 chart->setTitle("Pie chart");
                 qreal pieSize = 1.0 / m_dataTable.count();
                 for (int i = 0; i < m_dataTable.count(); i++) {
                     QPieSeries *series = new QPieSeries(chart);
                     foreach (Data data, m_dataTable[i]) {
                         QPieSlice *slice = series->append(data.second, data.first.y());
                         if (data == m_dataTable[i].first()) {
                             slice->setLabelVisible();
                             slice->setExploded();
                         }
                     }
                     qreal hPos = (pieSize / 2) + (i / (qreal) m_dataTable.count());
                     series->setPieSize(pieSize);
                     series->setHorizontalPosition(hPos);
                     series->setVerticalPosition(0.5);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart *ThemeWidget::createSplineChart() const
             {
                 // spine chart
                 QChart *chart = new QChart();
                 chart->setTitle("Spline chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QSplineSeries *series = new QSplineSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 chart->createDefaultAxes();
                 return chart;
             }
             QChart *ThemeWidget::createScatterChart() const
             {
                 // scatter chart
                 QChart *chart = new QChart();
                 chart->setTitle("Scatter chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QScatterSeries *series = new QScatterSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 chart->createDefaultAxes();
                 return chart;
             }
             void ThemeWidget::updateUI()
             {
                 QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(m_themeComboBox->currentIndex()).toInt();
                 if (m_charts.at(0)->chart()->theme() != theme) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setTheme(theme);
                     QPalette pal = window()->palette();
                     if (theme == QChart::ChartThemeLight) {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeDark) {
                         pal.setColor(QPalette::Window, QRgb(0x121218));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBlueCerulean) {
                         pal.setColor(QPalette::Window, QRgb(0x40434a));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBrownSand) {
                         pal.setColor(QPalette::Window, QRgb(0x9e8965));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeBlueNcs) {
                         pal.setColor(QPalette::Window, QRgb(0x018bba));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeHighContrast) {
                         pal.setColor(QPalette::Window, QRgb(0xffab03));
                         pal.setColor(QPalette::WindowText, QRgb(0x181818));
                     } else if (theme == QChart::ChartThemeBlueIcy) {
                         pal.setColor(QPalette::Window, QRgb(0xcee7f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     }
                     window()->setPalette(pal);
                 }
                 bool checked = m_antialiasCheckBox->isChecked();
                 foreach (QChartView *chart, m_charts)
                     chart->setRenderHint(QPainter::Antialiasing, checked);
                 QChart::AnimationOptions options(m_animatedComboBox->itemData(m_animatedComboBox->currentIndex()).toInt());
                 if (m_charts.at(0)->chart()->animationOptions() != options) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setAnimationOptions(options);
                 }
                 Qt::Alignment alignment(m_legendComboBox->itemData(m_legendComboBox->currentIndex()).toInt());
                 if (!alignment) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->legend()->hide();
                 } else {
                     foreach (QChartView *chartView, m_charts) {
                         chartView->chart()->legend()->setAlignment(alignment);
                         chartView->chart()->legend()->show();
                     }
                 }
             }

examples/charts/qmloscilloscope/qml/qmloscilloscope/ControlPanel.qml +11 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
-            import QtQuick 2.0
+            import QtQuick 2.1
             import QtQuick.Layouts 1.0
             ColumnLayout {
+                property alias openGLButton: openGLButton
                 spacing: 8
                 Layout.fillHeight: true
                 signal animationsEnabled(bool enabled)
                 signal seriesTypeChanged(string type)
                 signal refreshRateChanged(variant rate);
                 signal signalSourceChanged(string source, int signalCount, int sampleCount);
                 signal antialiasingEnabled(bool enabled)
+                signal openGlChanged(bool enabled)
                 Text {
                     text: "Scope"
                     font.pointSize: 18
                     color: "white"
                 }
                 MultiButton {
+                    id: openGLButton
+                    text: "OpenGL: "
+                    items: ["false", "true"]
+                    currentSelection: 0
+                    onSelectionChanged: openGlChanged(currentSelection == 1);
+                }
+                MultiButton {
                     text: "Graph: "
                     items: ["line", "spline", "scatter"]
                     currentSelection: 0
                     onSelectionChanged: seriesTypeChanged(items[currentSelection]);
                 }
                 MultiButton {
                     id: signalSourceButton
                     text: "Source: "
                     items: ["sin", "linear"]
                     currentSelection: 0
                     onSelectionChanged: signalSourceChanged(
                                             selection,
 ,
                                             sampleCountButton.items[sampleCountButton.currentSelection]);
                 }
                 MultiButton {
                     id: sampleCountButton
                     text: "Samples: "
                     items: [6, 128, 1024, 10000]
                     currentSelection: 2
                     onSelectionChanged: signalSourceChanged(
                                             signalSourceButton.items[signalSourceButton.currentSelection],
 ,
                                             selection);
                 }
                 MultiButton {
                     text: "Refresh rate: "
                     items: [1, 24, 60, 100]
                     currentSelection: 2
                     onSelectionChanged: refreshRateChanged(items[currentSelection]);
                 }
                 MultiButton {
                     text: "Animations: "
                     items: ["OFF", "ON"]
                     currentSelection: 0
                     onSelectionChanged: animationsEnabled(currentSelection == 1);
                 }
                 MultiButton {
                     text: "Antialias: "
                     items: ["OFF", "ON"]
                     currentSelection: 0
                     onSelectionChanged: antialiasingEnabled(currentSelection == 1);
                 }
             }

examples/charts/qmloscilloscope/qml/qmloscilloscope/ScopeView.qml +23 -6

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             import QtQuick 2.0
-            import QtCharts 2.0
+            import QtCharts 2.1
             //![1]
             ChartView {
                 id: chartView
                 animationOptions: ChartView.NoAnimation
                 theme: ChartView.ChartThemeDark
+                property bool openGL: false
+                onOpenGLChanged: {
+                    series("signal 1").useOpenGL = openGL;
+                    series("signal 2").useOpenGL = openGL;
+                }
                 ValueAxis {
                     id: axisY1
                     min: -1
                     max: 4
                 }
                 ValueAxis {
                     id: axisY2
                     min: -10
                     max: 5
                 }
                 ValueAxis {
                     id: axisX
                     min: 0
-                    max: 1000
+                    max: 1024
                 }
                 LineSeries {
                     id: lineSeries1
                     name: "signal 1"
                     axisX: axisX
                     axisY: axisY1
+                    useOpenGL: chartView.openGL
                 }
                 LineSeries {
                     id: lineSeries2
                     name: "signal 2"
                     axisX: axisX
                     axisYRight: axisY2
+                    useOpenGL: chartView.openGL
                 }
             //![1]
                 //![2]
                 Timer {
                     id: refreshTimer
                     interval: 1 / 60 * 1000 // 60 Hz
                     running: true
                     repeat: true
                     onTriggered: {
                         dataSource.update(chartView.series(0));
                         dataSource.update(chartView.series(1));
                     }
                 }
                 //![2]
                 //![3]
                 function changeSeriesType(type) {
                     chartView.removeAllSeries();
                     // Create two new series of the correct type. Axis x is the same for both of the series,
                     // but the series have their own y-axes to make it possible to control the y-offset
                     // of the "signal sources".
                     if (type == "line") {
-                        chartView.createSeries(ChartView.SeriesTypeLine, "signal 1", axisX, axisY1);
+                        var series1 = chartView.createSeries(ChartView.SeriesTypeLine, "signal 1",
-                        chartView.createSeries(ChartView.SeriesTypeLine, "signal 2", axisX, axisY2);
+                                                             axisX, axisY1);
+                        series1.useOpenGL = chartView.openGL
+                        var series2 = chartView.createSeries(ChartView.SeriesTypeLine, "signal 2",
+                                                             axisX, axisY2);
+                        series2.useOpenGL = chartView.openGL
                     } else if (type == "spline") {
                         chartView.createSeries(ChartView.SeriesTypeSpline, "signal 1", axisX, axisY1);
                         chartView.createSeries(ChartView.SeriesTypeSpline, "signal 2", axisX, axisY2);
                     } else {
-                        var series1 = chartView.createSeries(ChartView.SeriesTypeScatter, "signal 1", axisX, axisY1);
+                        var series1 = chartView.createSeries(ChartView.SeriesTypeScatter, "signal 1",
+                                                             axisX, axisY1);
                         series1.markerSize = 3;
                         series1.borderColor = "transparent";
-                        var series2 = chartView.createSeries(ChartView.SeriesTypeScatter, "signal 2", axisX, axisY2);
+                        series1.useOpenGL = chartView.openGL
+                        var series2 = chartView.createSeries(ChartView.SeriesTypeScatter, "signal 2",
+                                                             axisX, axisY2);
                         series2.markerSize = 3;
                         series2.borderColor = "transparent";
+                        series2.useOpenGL = chartView.openGL
                     }
                 }
                 function createAxis(min, max) {
                     // The following creates a ValueAxis object that can be then set as a x or y axis for a series
                     return Qt.createQmlObject("import QtQuick 2.0; import QtCharts 2.0; ValueAxis { min: "
                                               + min + "; max: " + max + " }", chartView);
                 }
                 //![3]
                 function setAnimations(enabled) {
                     if (enabled)
                         chartView.animationOptions = ChartView.SeriesAnimations;
                     else
                         chartView.animationOptions = ChartView.NoAnimation;
                 }
                 function changeRefreshRate(rate) {
                     refreshTimer.interval = 1 / Number(rate) * 1000;
                 }
             }

examples/charts/qmloscilloscope/qml/qmloscilloscope/main.qml +15 -3

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             import QtQuick 2.0
             //![1]
             Rectangle {
                 id: main
-                width: 400
+                width: 600
-                height: 300
+                height: 400
                 color: "#404040"
                 ControlPanel {
                     id: controlPanel
                     anchors.top: parent.top
                     anchors.topMargin: 10
                     anchors.bottom: parent.bottom
                     anchors.left: parent.left
                     anchors.leftMargin: 10
             //![1]
                     onSignalSourceChanged: {
                         if (source == "sin")
                             dataSource.generateData(0, signalCount, sampleCount);
                         else
                             dataSource.generateData(1, signalCount, sampleCount);
+                        scopeView.axisX().max = sampleCount;
                     }
                     onAnimationsEnabled: scopeView.setAnimations(enabled);
-                    onSeriesTypeChanged: scopeView.changeSeriesType(type);
+                    onSeriesTypeChanged: {
+                        scopeView.changeSeriesType(type);
+                        if (type === "spline") {
+                            controlPanel.openGLButton.currentSelection = 0;
+                            controlPanel.openGLButton.enabled = false;
+                            scopeView.openGL = false;
+                        } else {
+                            controlPanel.openGLButton.enabled = true;
+                        }
+                    }
                     onRefreshRateChanged: scopeView.changeRefreshRate(rate);
                     onAntialiasingEnabled: scopeView.antialiasing = enabled;
+                    onOpenGlChanged: scopeView.openGL = enabled;
                 }
             //![2]
                 ScopeView {
                     id: scopeView
                     anchors.top: parent.top
                     anchors.bottom: parent.bottom
                     anchors.right: parent.right
                     anchors.left: controlPanel.right
                     height: main.height
                 }
             //![2]
             }

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

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtCharts/QAreaSeries>
             #include <private/qareaseries_p.h>
             #include <QtCharts/QLineSeries>
             #include <private/areachartitem_p.h>
             #include <private/abstractdomain_p.h>
             #include <private/chartdataset_p.h>
             #include <private/charttheme_p.h>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QAreaLegendMarker>
             #include <private/qchart_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QAreaSeries
                 \inmodule Qt Charts
                 \brief The QAreaSeries class is used for making area charts.
                 An area series is used to show quantitative data. It is based on line series, in the way that
                 the area between the boundary lines is emphasized with color. Since the area series is based on
                 line series, QAreaSeries constructor needs a QLineSeries instance, which defines "upper"
                 boundary of the area. The area chart is drawn using the bottom of the plot area as the "lower"
                 boundary by default. Instead of the bottom of the plot area, the "lower" boundary can be
                 specified by another line. In that case QAreaSeries should be initialized with two QLineSeries
                 instances. Please note that the terms "upper" and "lower" boundary can be misleading in cases
                 where the "lower" boundary has bigger values than the "upper" one. The main point is that the
                 area between these two boundary lines will be filled.
                 See the \l {AreaChart Example} {area chart example} to learn how to create a simple area chart.
                 \image examples_areachart.png
             */
             /*!
                 \qmltype AreaSeries
                 \instantiates QAreaSeries
                 \inqmlmodule QtCharts
                 \inherits AbstractSeries
                 \brief The AreaSeries type is used for making area charts.
                 The following QML shows how to create a simple area chart:
                 \snippet qmlchart/qml/qmlchart/View4.qml 1
                 \beginfloatleft
                 \image examples_qmlchart4.png
                 \endfloat
                 \clearfloat
                 \note Adding the same line series to chart and area series is not supported. The series used as
                 boundary lines should be defined only for the area series.
             */
             /*!
                \property QAreaSeries::upperSeries
                \brief The upper one of the two line series used to define area series boundaries.
             */
             /*!
                \qmlproperty LineSeries AreaSeries::upperSeries
                The upper one of the two line series used to define area series boundaries.
             */
             /*!
                 \property QAreaSeries::lowerSeries
                 The lower one of the two line series used to define are series boundaries. Note if
                 QAreaSeries was constructed without a\ lowerSeries this is null.
             */
             /*!
                 \qmlproperty LineSeries AreaSeries::lowerSeries
                 The lower one of the two line series used to define are series boundaries. Note if
                 AreaSeries was constructed without a\ lowerSeries this is null.
             */
             /*!
                 \property QAreaSeries::color
                 Fill (brush) color of the series. This is a convenience property for modifying the color of brush.
                 \sa QAreaSeries::brush()
             */
             /*!
                 \qmlproperty color AreaSeries::color
                 Fill (brush) color of the series.
             */
             /*!
                 \property QAreaSeries::borderColor
                 Line (pen) color of the series. This is a convenience property for modifying the color of pen.
                 \sa QAreaSeries::pen()
             */
             /*!
                 \qmlproperty color AreaSeries::borderColor
                 Line (pen) color of the series.
             */
             /*!
                 \qmlproperty real AreaSeries::borderWidth
                 The width of the border line. By default the width is 2.0.
             */
             /*!
                \fn QPen QAreaSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn QPen QAreaSeries::brush() const
                \brief  Returns the brush used to draw line for this series.
                 \sa setBrush()
             */
             /*!
                 \qmlproperty QString AreaSeries::brushFilename
                 The name of the file used as a brush image for the series.
             */
             /*!
                 \fn void QAreaSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the fill (brush) color has changed to \a color.
             */
             /*!
                 \qmlsignal AreaSeries::onColorChanged(color color)
                 Signal is emitted when the fill (brush) color has changed to \a color.
             */
             /*!
                 \fn void QAreaSeries::borderColorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \qmlsignal AreaSeries::onBorderColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn void QAreaSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on area chart. The \a point is the point
                 where the press was triggered.
                 \sa pressed, released, doubleClicked
             */
             /*!
                 \qmlsignal AreaSeries::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on area chart. The \a point is the point where
                 the press was triggered.
                 \sa onPressed, onReleased, onDoubleClicked
             */
             /*!
                 \fn void QAreaSeries::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 AreaSeries::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 QAreaSeries::pressed(const QPointF& point)
                 \brief Signal is emitted when user presses the \a point on area chart.
                 \sa clicked, released, doubleClicked
             */
             /*!
                 \qmlsignal AreaSeries::onPressed(QPointF point)
                 Signal is emitted when user presses the \a point on area chart.
                 \sa onClicked, onReleased, onDoubleClicked
             */
             /*!
                 \fn void QAreaSeries::released(const QPointF& point)
                 \brief Signal is emitted when user releases a press that was triggered on a \a point on area
                 chart.
                 \sa pressed, clicked, doubleClicked
             */
             /*!
                 \qmlsignal AreaSeries::onReleased(QPointF point)
                 Signal is emitted when user releases a press that was triggered on a \a point on area chart.
                 \sa onPressed, onClicked, onDoubleClicked
             */
             /*!
                 \fn void QAreaSeries::doubleClicked(const QPointF& point)
                 \brief Signal is emitted when user doubleclicks the \a point on area chart. The \a point is the
                 point where the first press was triggered.
                 \sa pressed, released, clicked
             */
             /*!
                 \qmlsignal AreaSeries::onDoubleClicked(QPointF point)
                 Signal is emitted when user doubleclicks the \a point on area chart. The \a point is the point
                 where the first press was triggered.
                 \sa onPressed, onReleased, onClicked
             */
             /*!
                 \fn void QAreaSeries::selected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of QAreaSeries API.
             */
             /*!
                 \qmlsignal AreaSeries::onSelected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of AreaSeries API.
             */
             /*!
                 \fn void QAreaSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \property QAreaSeries::pointLabelsFormat
                 The \a format used for showing labels with series points.
                 QAreaSeries supports the following format tags:
                 \table
                   \row
                     \li @xPoint      \li The x value of the data point
                   \row
                     \li @yPoint      \li The y value of the data point
                 \endtable
                 For example, the following usage of the format tags would produce labels that have the data
                 point (x, y) shown inside brackets separated by a comma:
                 \code
                 series->setPointLabelsFormat("(@xPoint, @yPoint)");
                 \endcode
                 By default, the labels format is set to '@xPoint, @yPoint'. The labels are shown on the plot
                 area, labels on the edge of the plot area are cut. If the points are close to each other the
                 labels may overlap.
                 \sa QAreaSeries::pointLabelsVisible, QAreaSeries::pointLabelsFont, QAreaSeries::pointLabelsColor
             */
             /*!
                 \qmlproperty string AreaSeries::pointLabelsFormat
                 The \a format used for showing labels with series points.
                 \sa QAreaSeries::pointLabelsFormat, pointLabelsVisible, pointLabelsFont, pointLabelsColor
             */
             /*!
                 \fn void QAreaSeries::pointLabelsFormatChanged(const QString &format)
                 Signal is emitted when the \a format of data point labels is changed.
             */
             /*!
                 \qmlsignal AreaSeries::onPointLabelsFormatChanged(string format)
                 Signal is emitted when the \a format of data point labels is changed.
             */
             /*!
                 \property QAreaSeries::pointLabelsVisible
                 Defines the visibility for data point labels. False by default.
                 \sa QAreaSeries::pointLabelsFormat, QAreaSeries::pointLabelsClipping
             */
             /*!
                 \qmlproperty bool AreaSeries::pointLabelsVisible
                 Defines the visibility for data point labels.
                 \sa pointLabelsFormat, pointLabelsClipping
             */
             /*!
                 \fn void QAreaSeries::pointLabelsVisibilityChanged(bool visible)
                 The visibility of the data point labels is changed to \a visible.
             */
             /*!
                 \qmlsignal AreaSeries::onPointLabelsVisibilityChanged(bool visible)
                 The visibility of the data point labels is changed to \a visible.
             */
             /*!
                 \property QAreaSeries::pointLabelsFont
                 Defines the font used for data point labels.
                 \sa QAreaSeries::pointLabelsFormat
             */
             /*!
                 \qmlproperty font AreaSeries::pointLabelsFont
                 Defines the font used for data point labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QAreaSeries::pointLabelsFontChanged(const QFont &font);
                 The font used for data point labels is changed to \a font.
             */
             /*!
                 \qmlsignal AreaSeries::onPointLabelsFontChanged(Font font)
                 The font used for data point labels is changed to \a font.
             */
             /*!
                 \property QAreaSeries::pointLabelsColor
                 Defines the color used for data point labels. By default, the color is the color of the brush
                 defined in theme for labels.
                 \sa QAreaSeries::pointLabelsFormat
             */
             /*!
                 \qmlproperty font AreaSeries::pointLabelsColor
                 Defines the color used for data point labels. By default, the color is the color of the brush
                 defined in theme for labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QAreaSeries::pointLabelsColorChanged(const QColor &color);
                 The color used for data point labels is changed to \a color.
             */
             /*!
                 \qmlsignal AreaSeries::onPointLabelsColorChanged(Color color)
                 The color used for data point labels is changed to \a color.
             */
             /*!
                 \property QAreaSeries::pointLabelsClipping
                 Defines the clipping for data point labels. True by default. The labels on the edge of the plot
                 area are cut when clipping is enabled.
                 \sa pointLabelsVisible
             */
             /*!
                 \qmlproperty bool AreaSeries::pointLabelsClipping
                 Defines the clipping for data point labels. True by default. The labels on the edge of the plot
                 area are cut when clipping is enabled.
                 \sa pointLabelsVisible
             */
             /*!
-                \fn void QAreaSeries::pointLabelsClippintChanged(bool clipping)
+                \fn void QAreaSeries::pointLabelsClippingChanged(bool clipping)
                 The clipping of the data point labels is changed to \a clipping.
             */
             /*!
                 \qmlsignal AreaSeries::onPointLabelsClippingChanged(bool clipping)
                 The clipping of the data point labels is changed to \a clipping.
             */
             /*!
                 Constructs area series object which is a child of \a upperSeries. Area will be spanned between \a
                 upperSeries line and \a lowerSeries line.  If no \a lowerSeries is passed to constructor, area is specified by axis x (y=0) instead.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QAreaSeries::QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries)
                 : QAbstractSeries(*new QAreaSeriesPrivate(upperSeries, lowerSeries, this), upperSeries)
             {
             }
             /*!
                 Constructs area series object without upper or lower series with \a parent object.
             */
             QAreaSeries::QAreaSeries(QObject *parent)
                 : QAbstractSeries(*new QAreaSeriesPrivate(0, 0, this), parent)
             {
             }
             /*!
                 Destroys the object.
             */
             QAreaSeries::~QAreaSeries()
             {
                 Q_D(QAreaSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
                 Returns QAbstractSeries::SeriesTypeArea.
             */
             QAbstractSeries::SeriesType QAreaSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeArea;
             }
             /*!
                 Sets the \a series that is to be used as the area chart upper series.
             */
             void QAreaSeries::setUpperSeries(QLineSeries *series)
             {
                 Q_D(QAreaSeries);
-                if (d->m_upperSeries != series)
+                if (d->m_upperSeries != series) {
+                    series->d_ptr->setBlockOpenGL(true);
                     d->m_upperSeries = series;
+                }
             }
             QLineSeries *QAreaSeries::upperSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_upperSeries;
             }
             /*!
                 Sets the \a series that is to be used as the area chart lower series.
             */
             void QAreaSeries::setLowerSeries(QLineSeries *series)
             {
                 Q_D(QAreaSeries);
+                series->d_ptr->setBlockOpenGL(true);
                 d->m_lowerSeries = series;
             }
             QLineSeries *QAreaSeries::lowerSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_lowerSeries;
             }
             /*!
                 Sets \a pen used for drawing area outline.
             */
             void QAreaSeries::setPen(const QPen &pen)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pen != pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen QAreaSeries::pen() const
             {
                 Q_D(const QAreaSeries);
                 if (d->m_pen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d->m_pen;
             }
             /*!
                 Sets \a brush used for filling the area.
             */
             void QAreaSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QAreaSeries);
                 if (d->m_brush != brush) {
                     bool emitColorChanged = brush.color() != d->m_brush.color();
                     d->m_brush = brush;
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(brush.color());
                 }
             }
             QBrush QAreaSeries::brush() const
             {
                 Q_D(const QAreaSeries);
                 if (d->m_brush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d->m_brush;
             }
             void QAreaSeries::setColor(const QColor &color)
             {
                 QBrush b = brush();
                 if (b == QBrush())
                     b.setStyle(Qt::SolidPattern);
                 b.setColor(color);
                 setBrush(b);
             }
             QColor QAreaSeries::color() const
             {
                 return brush().color();
             }
             void QAreaSeries::setBorderColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             QColor QAreaSeries::borderColor() const
             {
                 return pen().color();
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QAreaSeries::setPointsVisible(bool visible)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             /*!
                 Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             bool QAreaSeries::pointsVisible() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointsVisible;
             }
             void QAreaSeries::setPointLabelsFormat(const QString &format)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointLabelsFormat != format) {
                     d->m_pointLabelsFormat = format;
                     emit pointLabelsFormatChanged(format);
                 }
             }
             QString QAreaSeries::pointLabelsFormat() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointLabelsFormat;
             }
             void QAreaSeries::setPointLabelsVisible(bool visible)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointLabelsVisible != visible) {
                     d->m_pointLabelsVisible = visible;
                     emit pointLabelsVisibilityChanged(visible);
                 }
             }
             bool QAreaSeries::pointLabelsVisible() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointLabelsVisible;
             }
             void QAreaSeries::setPointLabelsFont(const QFont &font)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointLabelsFont != font) {
                     d->m_pointLabelsFont = font;
                     emit pointLabelsFontChanged(font);
                 }
             }
             QFont QAreaSeries::pointLabelsFont() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointLabelsFont;
             }
             void QAreaSeries::setPointLabelsColor(const QColor &color)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointLabelsColor != color) {
                     d->m_pointLabelsColor = color;
                     emit pointLabelsColorChanged(color);
                 }
             }
             QColor QAreaSeries::pointLabelsColor() const
             {
                 Q_D(const QAreaSeries);
                 if (d->m_pointLabelsColor == QChartPrivate::defaultPen().color())
                     return QPen().color();
                 else
                     return d->m_pointLabelsColor;
             }
             void QAreaSeries::setPointLabelsClipping(bool enabled)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointLabelsClipping != enabled) {
                     d->m_pointLabelsClipping = enabled;
                     emit pointLabelsClippingChanged(enabled);
                 }
             }
             bool QAreaSeries::pointLabelsClipping() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointLabelsClipping;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries, QAreaSeries *q)
                 : QAbstractSeriesPrivate(q),
                   m_brush(QChartPrivate::defaultBrush()),
                   m_pen(QChartPrivate::defaultPen()),
                   m_upperSeries(upperSeries),
                   m_lowerSeries(lowerSeries),
                   m_pointsVisible(false),
                   m_pointLabelsFormat(QLatin1String("@xPoint, @yPoint")),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFont(QChartPrivate::defaultFont()),
                   m_pointLabelsColor(QChartPrivate::defaultPen().color()),
                   m_pointLabelsClipping(true)
             {
             }
             void QAreaSeriesPrivate::initializeDomain()
             {
                 Q_Q(QAreaSeries);
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 QLineSeries *upperSeries = q->upperSeries();
                 QLineSeries *lowerSeries = q->lowerSeries();
                 if (upperSeries) {
-                    const QList<QPointF>& points = upperSeries->points();
+                    const QVector<QPointF> &points = upperSeries->pointsVector();
                     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);
                     }
                 }
                 if (lowerSeries) {
+                    const QVector<QPointF> &points = lowerSeries->pointsVector();
-                    const QList<QPointF>& points = lowerSeries->points();
                     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);
             }
             void QAreaSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem *area = new AreaChartItem(q,parent);
                 m_item.reset(area);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             void  QAreaSeriesPrivate::initializeAnimations(QChart::AnimationOptions options, int duration,
                                                            QEasingCurve &curve)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem *area = static_cast<AreaChartItem *>(m_item.data());
                 if (q->upperSeries() && area->upperLineItem()->animation())
                     area->upperLineItem()->animation()->stopAndDestroyLater();
                 if (q->lowerSeries() && area->lowerLineItem()->animation())
                     area->lowerLineItem()->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations)) {
                     area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem(), duration,
                                                                         curve));
                     if (q->lowerSeries())
                         area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem(), duration,
                                                                             curve));
                 } else {
                     if (q->upperSeries())
                         area->upperLineItem()->setAnimation(0);
                     if (q->lowerSeries())
                            area->lowerLineItem()->setAnimation(0);
                 }
                 QAbstractSeriesPrivate::initializeAnimations(options, duration, curve);
             }
             QList<QLegendMarker*> QAreaSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QAreaSeries);
                 QList<QLegendMarker*> list;
                 return list << new QAreaLegendMarker(q,legend);
             }
             void QAreaSeriesPrivate::initializeAxes()
             {
             }
             QAbstractAxis::AxisType QAreaSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValue;
             }
             QAbstractAxis* QAreaSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return new QValueAxis;
             }
             void QAreaSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 Q_Q(QAreaSeries);
                 const QList<QGradient> gradients = theme->seriesGradients();
                 const QList<QColor> colors = theme->seriesColors();
                 if (forced || QChartPrivate::defaultPen() == m_pen) {
                     QPen pen;
                     pen.setColor(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0));
                     pen.setWidthF(2);
                     q->setPen(pen);
                 }
                 if (forced || QChartPrivate::defaultBrush() == m_brush) {
                     QBrush brush(colors.at(index % colors.size()));
                     q->setBrush(brush);
                 }
                 if (forced || QChartPrivate::defaultPen().color() == m_pointLabelsColor) {
                     QColor color = theme->labelBrush().color();
                     q->setPointLabelsColor(color);
                 }
             }
             #include "moc_qareaseries.cpp"
             #include "moc_qareaseries_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/axis/qabstractaxis.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtCharts/QAbstractAxis>
             #include <private/qabstractaxis_p.h>
             #include <private/chartdataset_p.h>
             #include <private/charttheme_p.h>
             #include <private/qchart_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QAbstractAxis
                 \inmodule Qt Charts
                 \brief The QAbstractAxis class is used for manipulating chart's axis.
                 Each series can be bound to one or more horizontal and vertical axes, but mixing axis types
                 that would result in different domains is not supported, such as specifying
                 QValueAxis and QLogValueAxis on the same orientation.
                 Properties and visibility of various axis elements such as axis line, title, labels, grid lines,
                 and shades can be individually controlled.
             */
             /*!
                 \qmltype AbstractAxis
                 \instantiates QAbstractAxis
                 \inqmlmodule QtCharts
                 \brief The AbstractAxis is a base element used for specialized axis elements.
                 Each series can be bound to only one horizontal and vertical axis.
                 Properties and visibility of various axis elements such as axis line, title, labels, grid lines,
                 and shades can be individually controlled.
             */
             /*!
                 \enum QAbstractAxis::AxisType
                 The type of the axis object.
                 \value AxisTypeNoAxis
                 \value AxisTypeValue
                 \value AxisTypeBarCategory
                 \value AxisTypeCategory
                 \value AxisTypeDateTime
                 \value AxisTypeLogValue
             */
             /*!
              *\fn void QAbstractAxis::type() const
               Returns the type of the axis
             */
             /*!
               \property QAbstractAxis::lineVisible
               The visibility of the axis line
             */
             /*!
               \qmlproperty bool AbstractAxis::lineVisible
               The visibility of the axis line
             */
             /*!
               \property QAbstractAxis::linePen
               The pen of the line.
             */
             /*!
               \property QAbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \qmlproperty bool AbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \property QAbstractAxis::labelsBrush
               The brush of the labels. Only the color of the brush is relevant.
             */
             /*!
               \property QAbstractAxis::visible
               The visibility of the axis.
             */
             /*!
               \qmlproperty bool AbstractAxis::visible
               The visibility of the axis.
             */
             /*!
               \property QAbstractAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \qmlproperty bool AbstractAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \property QAbstractAxis::minorGridVisible
               The visibility of the minor grid lines. Applies only to QValueAxis.
             */
             /*!
               \qmlproperty bool AbstractAxis::minorGridVisible
               The visibility of the minor grid lines. Applies only to QValueAxis.
             */
             /*!
               \property QAbstractAxis::color
               The color of the axis and ticks.
             */
             /*!
               \qmlproperty color AbstractAxis::color
               The color of the axis and ticks.
             */
             /*!
               \property QAbstractAxis::gridLinePen
               The pen of the grid line.
             */
             /*!
               \property QAbstractAxis::minorGridLinePen
               The pen of the minor grid line. Applies only to QValueAxis.
             */
             /*!
               \property QAbstractAxis::gridLineColor
               The color of the grid line.
             */
             /*!
               \property QAbstractAxis::minorGridLineColor
               The color of the minor grid line. Applies only to QValueAxis.
             */
             /*!
               \property QAbstractAxis::labelsFont
               The font of the axis labels.
             */
             /*!
               \qmlproperty Font AbstractAxis::labelsFont
               The font of the axis labels.
               See the Qt documentation for more details of Font.
             */
             /*!
               \property QAbstractAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \qmlproperty color AbstractAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \property QAbstractAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \qmlproperty int AbstractAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \property QAbstractAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \qmlproperty bool AbstractAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \qmlproperty color AbstractAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \qmlproperty color AbstractAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesPen
               The pen of the axis shades (area between grid lines).
             */
             /*!
               \property QAbstractAxis::shadesBrush
               The brush of the axis shades (area between grid lines).
             */
             /*!
               \property QAbstractAxis::titleVisible
               The visibility of the axis title. By default the value is true.
             */
             /*!
               \qmlproperty bool AbstractAxis::titleVisible
               The visibility of the axis title. By default the value is true.
             */
             /*!
               \property QAbstractAxis::titleText
               The title of the axis. Empty by default. Axis titles support html formatting.
             */
             /*!
               \qmlproperty String AbstractAxis::titleText
               The title of the axis. Empty by default. Axis titles support html formatting.
             */
             /*!
               \property QAbstractAxis::titleBrush
               The brush of the title text. Only the color of the brush is relevant.
             */
             /*!
               \property QAbstractAxis::titleFont
               The font of the title of the axis.
             */
             /*!
               \qmlproperty Font AbstractAxis::titleFont
               The font of the title of the axis.
             */
             /*!
               \property QAbstractAxis::orientation
               The orientation of the axis. Fixed to either Qt::Horizontal or Qt::Vertical when you add the axis to a chart.
             */
             /*!
               \qmlproperty Qt.Orientation AbstractAxis::orientation
               The orientation of the axis. Fixed to either Qt.Horizontal or Qt.Vertical when the axis is set to a series.
             */
             /*!
               \property QAbstractAxis::alignment
               The alignment of the axis. Can be Qt::AlignLeft, Qt::AlignRight, Qt::AlignBottom, or Qt::AlignTop.
             */
             /*!
               \qmlproperty alignment AbstractAxis::alignment
               The alignment of the axis. Can be Qt.AlignLeft, Qt.AlignRight, Qt.AlignBottom, or Qt.AlignTop.
             */
             /*!
               \property QAbstractAxis::reverse
               The reverse property defines if reverse axis is used. By default the value is false.
               Reverse axis is supported with line, spline, scatter and area series with cartesian chart.
               All axes of the same orientation attached to same series must be reversed if one is reversed or
               the behavior is undefined.
             */
             /*!
               \qmlproperty alignment AbstractAxis::reverse
               The reverse property defines if reverse axis is used. By default the value is false.
               Reverse axis is supported with line, spline, scatter and area series with cartesian chart.
               All axes of the same orientation attached to same series must be reversed if one is reversed or
               the behavior is undefined.
             */
             /*!
               \fn void QAbstractAxis::visibleChanged(bool visible)
               Visibility of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onVisibleChanged(bool visible)
               Visibility of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::linePenChanged(const QPen& pen)
               The pen of the line of the axis has changed to \a pen.
             */
             /*!
               \fn void QAbstractAxis::lineVisibleChanged(bool visible)
               Visibility of the axis line has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onLineVisibleChanged(bool visible)
               Visibility of the axis line has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::labelsVisibleChanged(bool visible)
               Visibility of the labels of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsVisibleChanged(bool visible)
               Visibility of the labels of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::labelsFontChanged(const QFont& font)
               The font of the axis labels has changed to \a font.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsFontChanged(Font font)
               The font of the axis labels has changed to \a font.
             */
             /*!
               \fn void QAbstractAxis::labelsBrushChanged(const QBrush& brush)
               The brush of the axis labels has changed to \a brush.
             */
             /*!
               \fn void QAbstractAxis::labelsAngleChanged(int angle)
               The angle of the axis labels has changed to \a angle.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsAngleChanged(int angle)
               The angle of the axis labels has changed to \a angle.
             */
             /*!
               \fn void QAbstractAxis::gridVisibleChanged(bool visible)
               Visibility of the grid lines of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onGridVisibleChanged(bool visible)
               Visibility of the grid lines of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::minorGridVisibleChanged(bool visible)
               Visibility of the minor grid lines of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onMinorGridVisibleChanged(bool visible)
               Visibility of the minor grid lines of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::gridLinePenChanged(const QPen& pen)
               The pen of the grid line has changed to \a pen.
             */
             /*!
               \fn void QAbstractAxis::minorGridLinePenChanged(const QPen& pen)
               The pen of the minor grid line has changed to \a pen.
             */
             /*!
               \fn void QAbstractAxis::gridLineColorChanged(const QColor &color)
               The color of the pen of the grid line has changed to \a color.
             */
             /*!
               \fn void QAbstractAxis::minorGridLineColorChanged(const QColor &color)
               The color of the pen of the minor grid line has changed to \a color.
             */
             /*!
               \fn void QAbstractAxis::colorChanged(QColor color)
               Emitted if the \a color of the axis is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onColorChanged(QColor color)
               Emitted if the \a color of the axis is changed.
             */
             /*!
               \fn void QAbstractAxis::labelsColorChanged(QColor color)
               Emitted if the \a color of the axis labels is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsColorChanged(QColor color)
               Emitted if the \a color of the axis labels is changed.
             */
             /*!
               \fn void QAbstractAxis::titleVisibleChanged(bool visible)
               Visibility of the title text of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onTitleVisibleChanged(bool visible)
               Visibility of the title text of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::titleTextChanged(const QString& text)
               The text of the axis title has changed to \a text.
             */
             /*!
               \qmlsignal AbstractAxis::onTitleTextChanged(String text)
               The text of the axis title has changed to \a text.
             */
             /*!
               \fn void QAbstractAxis::titleBrushChanged(const QBrush& brush)
               The brush of the axis title has changed to \a brush.
             */
             /*!
               \fn void QAbstractAxis::titleFontChanged(const QFont& font)
               The font of the axis title has changed to \a font.
             */
             /*!
               \qmlsignal AbstractAxis::onTitleFontChanged(Font font)
               The font of the axis title has changed to \a font.
             */
             /*!
               \fn void QAbstractAxis::shadesVisibleChanged(bool)
               Emitted if the visibility of the axis shades is changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onShadesVisibleChanged(bool visible)
               Emitted if the visibility of the axis shades is changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::shadesColorChanged(QColor color)
               Emitted if the \a color of the axis shades is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onShadesColorChanged(QColor color)
               Emitted if the \a color of the axis shades is changed.
             */
             /*!
               \fn void QAbstractAxis::shadesBorderColorChanged(QColor)
               Emitted if the border \a color of the axis shades is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onBorderColorChanged(QColor color)
               Emitted if the border \a color of the axis shades is changed.
             */
             /*!
               \fn void QAbstractAxis::shadesBrushChanged(const QBrush& brush)
               The brush of the axis shades has changed to \a brush.
             */
             /*!
               \fn void QAbstractAxis::shadesPenChanged(const QPen& pen)
               The pen of the axis shades has changed to \a pen.
             */
             /*!
              \internal
               Constructs new axis object which is a child of \a parent. Ownership is taken by
               QChart when axis added.
             */
             QAbstractAxis::QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent)
                 : QObject(parent),
                   d_ptr(&d)
             {
             }
             /*!
               Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
             QAbstractAxis::~QAbstractAxis()
             {
                 if (d_ptr->m_chart)
                     qFatal("Still binded axis detected !");
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
             void QAbstractAxis::setLinePen(const QPen &pen)
             {
                 if (d_ptr->m_axisPen != pen) {
                     d_ptr->m_axisPen = pen;
                     emit linePenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw axis and ticks.
             */
             QPen QAbstractAxis::linePen() const
             {
                 if (d_ptr->m_axisPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_axisPen;
             }
             void QAbstractAxis::setLinePenColor(QColor color)
             {
                 QPen p = d_ptr->m_axisPen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setLinePen(p);
                     emit colorChanged(color);
                 }
             }
             QColor QAbstractAxis::linePenColor() const
             {
                 return linePen().color();
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
             void QAbstractAxis::setLineVisible(bool visible)
             {
                 if (d_ptr->m_arrowVisible != visible) {
                     d_ptr->m_arrowVisible = visible;
                     emit lineVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isLineVisible() const
             {
                 return d_ptr->m_arrowVisible;
             }
             void QAbstractAxis::setGridLineVisible(bool visible)
             {
                 if (d_ptr->m_gridLineVisible != visible) {
                     d_ptr->m_gridLineVisible = visible;
                     emit gridVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isGridLineVisible() const
             {
                 return d_ptr->m_gridLineVisible;
             }
             void QAbstractAxis::setMinorGridLineVisible(bool visible)
             {
                 if (d_ptr->m_minorGridLineVisible != visible) {
                     d_ptr->m_minorGridLineVisible = visible;
                     emit minorGridVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isMinorGridLineVisible() const
             {
                 return d_ptr->m_minorGridLineVisible;
             }
             /*!
               Sets \a pen used to draw grid line.
             */
             void QAbstractAxis::setGridLinePen(const QPen &pen)
             {
                 if (d_ptr->m_gridLinePen != pen) {
                     d_ptr->m_gridLinePen = pen;
                     emit gridLinePenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw grid.
             */
             QPen QAbstractAxis::gridLinePen() const
             {
                 if (d_ptr->m_gridLinePen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_gridLinePen;
             }
             void QAbstractAxis::setMinorGridLinePen(const QPen &pen)
             {
                 if (d_ptr->m_minorGridLinePen != pen) {
                     d_ptr->m_minorGridLinePen = pen;
                     emit minorGridLinePenChanged(pen);
                 }
             }
             QPen QAbstractAxis::minorGridLinePen() const
             {
                 if (d_ptr->m_minorGridLinePen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_minorGridLinePen;
             }
             void QAbstractAxis::setGridLineColor(const QColor &color)
             {
                 QPen pen = d_ptr->m_gridLinePen;
                 if (color != pen.color()) {
                     pen.setColor(color);
                     d_ptr->m_gridLinePen = pen;
                     emit gridLineColorChanged(color);
                 }
             }
             QColor QAbstractAxis::gridLineColor()
             {
                 return d_ptr->m_gridLinePen.color();
             }
             void QAbstractAxis::setMinorGridLineColor(const QColor &color)
             {
                 QPen pen = d_ptr->m_minorGridLinePen;
                 if (color != pen.color()) {
                     pen.setColor(color);
                     d_ptr->m_minorGridLinePen = pen;
                     emit minorGridLineColorChanged(color);
                 }
             }
             QColor QAbstractAxis::minorGridLineColor()
             {
                 return d_ptr->m_minorGridLinePen.color();
             }
             void QAbstractAxis::setLabelsVisible(bool visible)
             {
                 if (d_ptr->m_labelsVisible != visible) {
                     d_ptr->m_labelsVisible = visible;
                     emit labelsVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::labelsVisible() const
             {
                 return d_ptr->m_labelsVisible;
             }
             /*!
               Sets \a brush used to draw labels.
              */
             void QAbstractAxis::setLabelsBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelsBrush != brush) {
                     d_ptr->m_labelsBrush = brush;
                     emit labelsBrushChanged(brush);
                 }
             }
             /*!
               Returns brush used to draw labels.
             */
             QBrush  QAbstractAxis::labelsBrush() const
             {
                 if (d_ptr->m_labelsBrush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d_ptr->m_labelsBrush;
             }
             /*!
               Sets \a font used to draw labels.
             */
             void QAbstractAxis::setLabelsFont(const QFont &font)
             {
                 if (d_ptr->m_labelsFont != font) {
                     d_ptr->m_labelsFont = font;
                     emit labelsFontChanged(font);
                 }
             }
             /*!
               Returns font used to draw labels.
             */
             QFont QAbstractAxis::labelsFont() const
             {
                 if (d_ptr->m_labelsFont == QChartPrivate::defaultFont())
                     return QFont();
                 else
                     return d_ptr->m_labelsFont;
             }
             void QAbstractAxis::setLabelsAngle(int angle)
             {
                 if (d_ptr->m_labelsAngle != angle) {
                     d_ptr->m_labelsAngle = angle;
                     emit labelsAngleChanged(angle);
                 }
             }
             int QAbstractAxis::labelsAngle() const
             {
                 return d_ptr->m_labelsAngle;
             }
             void QAbstractAxis::setLabelsColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelsBrush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setLabelsBrush(b);
                     emit labelsColorChanged(color);
                 }
             }
             QColor QAbstractAxis::labelsColor() const
             {
                 return labelsBrush().color();
             }
             void QAbstractAxis::setTitleVisible(bool visible)
             {
                 if (d_ptr->m_titleVisible != visible) {
                     d_ptr->m_titleVisible = visible;
                     emit titleVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isTitleVisible() const
             {
                 return d_ptr->m_titleVisible;
             }
             /*!
               Sets \a brush used to draw title.
              */
             void QAbstractAxis::setTitleBrush(const QBrush &brush)
             {
                 if (d_ptr->m_titleBrush != brush) {
                     d_ptr->m_titleBrush = brush;
                     emit titleBrushChanged(brush);
                 }
             }
             /*!
               Returns brush used to draw title.
             */
             QBrush QAbstractAxis::titleBrush() const
             {
                 if (d_ptr->m_titleBrush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d_ptr->m_titleBrush;
             }
             /*!
               Sets \a font used to draw title.
             */
             void QAbstractAxis::setTitleFont(const QFont &font)
             {
                 if (d_ptr->m_titleFont != font) {
                     d_ptr->m_titleFont = font;
                     emit titleFontChanged(font);
                 }
             }
             /*!
               Returns font used to draw title.
             */
             QFont QAbstractAxis::titleFont() const
             {
                 if (d_ptr->m_titleFont == QChartPrivate::defaultFont())
                     return QFont();
                 else
                     return d_ptr->m_titleFont;
             }
             void QAbstractAxis::setTitleText(const QString &title)
             {
                 if (d_ptr->m_title != title) {
                     d_ptr->m_title = title;
                     emit titleTextChanged(title);
                 }
             }
             QString QAbstractAxis::titleText() const
             {
                 return d_ptr->m_title;
             }
             void QAbstractAxis::setShadesVisible(bool visible)
             {
                 if (d_ptr->m_shadesVisible != visible) {
                     d_ptr->m_shadesVisible = visible;
                     emit shadesVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::shadesVisible() const
             {
                 return d_ptr->m_shadesVisible;
             }
             /*!
               Sets \a pen used to draw shades.
             */
             void QAbstractAxis::setShadesPen(const QPen &pen)
             {
                 if (d_ptr->m_shadesPen != pen) {
                     d_ptr->m_shadesPen = pen;
                     emit shadesPenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw shades.
             */
             QPen QAbstractAxis::shadesPen() const
             {
                 if (d_ptr->m_shadesPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_shadesPen;
             }
             /*!
               Sets \a brush used to draw shades.
             */
             void QAbstractAxis::setShadesBrush(const QBrush &brush)
             {
                 if (d_ptr->m_shadesBrush != brush) {
                     d_ptr->m_shadesBrush = brush;
                     emit shadesBrushChanged(brush);
                 }
             }
             /*!
                Returns brush used to draw shades.
             */
             QBrush QAbstractAxis::shadesBrush() const
             {
                 if (d_ptr->m_shadesBrush == QChartPrivate::defaultBrush())
                     return QBrush(Qt::SolidPattern);
                 else
                     return d_ptr->m_shadesBrush;
             }
             void QAbstractAxis::setShadesColor(QColor color)
             {
                 QBrush b = d_ptr->m_shadesBrush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setShadesBrush(b);
                     emit shadesColorChanged(color);
                 }
             }
             QColor QAbstractAxis::shadesColor() const
             {
                 return shadesBrush().color();
             }
             void QAbstractAxis::setShadesBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_shadesPen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setShadesPen(p);
                     emit shadesColorChanged(color);
                 }
             }
             QColor QAbstractAxis::shadesBorderColor() const
             {
                 return shadesPen().color();
             }
             bool QAbstractAxis::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             /*!
-              Sets axis, shades, labels and grid lines to be visible.
+              Sets axis, shades, labels and grid lines visibility to \a visible.
             */
             void QAbstractAxis::setVisible(bool visible)
             {
                 if (d_ptr->m_visible != visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged(visible);
                 }
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAbstractAxis::show()
             {
                 setVisible(true);
             }
             /*!
               Sets axis, shades, labels and grid lines to not be visible.
             */
             void QAbstractAxis::hide()
             {
                 setVisible(false);
             }
             /*!
               Sets the minimum value shown on the axis.
               Depending on the actual axis type the \a min parameter is converted to appropriate type.
               If the conversion is impossible then the function call does nothing
             */
             void QAbstractAxis::setMin(const QVariant &min)
             {
                 d_ptr->setMin(min);
             }
             /*!
               Sets the maximum value shown on the axis.
               Depending on the actual axis type the \a max parameter is converted to appropriate type.
               If the conversion is impossible then the function call does nothing
             */
             void QAbstractAxis::setMax(const QVariant &max)
             {
                 d_ptr->setMax(max);
             }
             /*!
               Sets the range shown on the axis.
               Depending on the actual axis type the \a min and \a max parameters are converted to appropriate types.
               If the conversion is impossible then the function call does nothing.
             */
             void QAbstractAxis::setRange(const QVariant &min, const QVariant &max)
             {
                 d_ptr->setRange(min, max);
             }
             /*!
               Returns the orientation in which the axis is being used (Vertical or Horizontal)
             */
             Qt::Orientation QAbstractAxis::orientation() const
             {
                 return d_ptr->orientation();
             }
             Qt::Alignment QAbstractAxis::alignment() const
             {
                 return d_ptr->alignment();
             }
             bool QAbstractAxis::isReverse() const
             {
                 return d_ptr->m_reverse;
             }
             void QAbstractAxis::setReverse(bool reverse)
             {
                 if (d_ptr->m_reverse != reverse && type() != QAbstractAxis::AxisTypeBarCategory) {
                     d_ptr->m_reverse = reverse;
                     emit reverseChanged(reverse);
                 }
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis *q)
                 : q_ptr(q),
                   m_chart(0),
                   m_alignment(0),
                   m_orientation(Qt::Orientation(0)),
                   m_visible(true),
                   m_arrowVisible(true),
                   m_axisPen(QChartPrivate::defaultPen()),
                   m_axisBrush(QChartPrivate::defaultBrush()),
                   m_gridLineVisible(true),
                   m_gridLinePen(QChartPrivate::defaultPen()),
                   m_minorGridLineVisible(true),
                   m_minorGridLinePen(QChartPrivate::defaultPen()),
                   m_labelsVisible(true),
                   m_labelsBrush(QChartPrivate::defaultBrush()),
                   m_labelsFont(QChartPrivate::defaultFont()),
                   m_labelsAngle(0),
                   m_titleVisible(true),
                   m_titleBrush(QChartPrivate::defaultBrush()),
                   m_titleFont(QChartPrivate::defaultFont()),
                   m_shadesVisible(false),
                   m_shadesPen(QChartPrivate::defaultPen()),
                   m_shadesBrush(QChartPrivate::defaultBrush()),
                   m_shadesOpacity(1.0),
                   m_dirty(false),
                   m_reverse(false)
             {
             }
             QAbstractAxisPrivate::~QAbstractAxisPrivate()
             {
             }
             void QAbstractAxisPrivate::setAlignment( Qt::Alignment alignment)
             {
                 switch(alignment) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom:
                     m_orientation = Qt::Horizontal;
                     break;
                     case Qt::AlignLeft:
                     case Qt::AlignRight:
                     m_orientation = Qt::Vertical;
                     break;
                     default:
                     qWarning()<<"No alignment specified !";
                     break;
                 };
                 m_alignment=alignment;
             }
             void QAbstractAxisPrivate::initializeTheme(ChartTheme* theme, bool forced)
             {
                 if (forced || QChartPrivate::defaultPen() == m_axisPen)
                     q_ptr->setLinePen(theme->axisLinePen());
                 if (forced || QChartPrivate::defaultPen() == m_gridLinePen)
                     q_ptr->setGridLinePen(theme->gridLinePen());
                 if (forced || QChartPrivate::defaultPen() == m_minorGridLinePen)
                     q_ptr->setMinorGridLinePen(theme->minorGridLinePen());
                 if (forced || QChartPrivate::defaultBrush() == m_labelsBrush)
                     q_ptr->setLabelsBrush(theme->labelBrush());
                 if (forced || QChartPrivate::defaultFont() == m_labelsFont)
                     q_ptr->setLabelsFont(theme->labelFont());
                 if (forced || QChartPrivate::defaultBrush() == m_titleBrush)
                     q_ptr->setTitleBrush(theme->labelBrush());
                 if (forced || QChartPrivate::defaultFont() == m_titleFont) {
                     QFont font(m_labelsFont);
                     font.setBold(true);
                     q_ptr->setTitleFont(font);
                 }
                 if (forced || QChartPrivate::defaultBrush() == m_shadesBrush)
                     q_ptr->setShadesBrush(theme->backgroundShadesBrush());
                 if (forced || QChartPrivate::defaultPen() == m_shadesPen)
                     q_ptr->setShadesPen(theme->backgroundShadesPen());
                 bool axisX = m_orientation == Qt::Horizontal;
                 if (forced && (theme->backgroundShades() == ChartTheme::BackgroundShadesBoth
                         || (theme->backgroundShades() == ChartTheme::BackgroundShadesVertical && axisX)
                         || (theme->backgroundShades() == ChartTheme::BackgroundShadesHorizontal && !axisX))) {
                      q_ptr->setShadesVisible(true);
                 } else if (forced) {
                     q_ptr->setShadesVisible(false);
                 }
             }
             void QAbstractAxisPrivate::handleRangeChanged(qreal min, qreal max)
             {
                 setRange(min,max);
             }
             void QAbstractAxisPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_UNUSED(parent);
             }
             void QAbstractAxisPrivate::initializeAnimations(QChart::AnimationOptions options, int duration,
                                                             QEasingCurve &curve)
             {
                 ChartAxisElement *axis = m_item.data();
                 Q_ASSERT(axis);
                 if (axis->animation())
                     axis->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::GridAxisAnimations))
                     axis->setAnimation(new AxisAnimation(axis, duration, curve));
                 else
                     axis->setAnimation(0);
             }
             #include "moc_qabstractaxis.cpp"
             #include "moc_qabstractaxis_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/barchart/qbarset.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtCharts/QBarSet>
             #include <private/qbarset_p.h>
             #include <private/charthelpers_p.h>
             #include <private/qchart_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QBarSet
                 \inmodule Qt Charts
                 \brief Building block for different bar charts.
                 QBarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 Labels for zero value sets are not shown.
                 \sa QAbstractBarSeries, QBarSeries, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \qmltype BarSet
                 \instantiates QBarSet
                 \inqmlmodule QtCharts
                 \brief Building block for different bar charts.
                 BarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 Labels for zero value sets are not shown.
                 \sa AbstractBarSeries, BarSeries, StackedBarSeries, PercentBarSeries
             */
             /*!
                 \property QBarSet::label
                 Defines the label of the bar set.
             */
             /*!
                 \qmlproperty string BarSet::label
                 Defines the label of the bar set.
             */
             /*!
                 \property QBarSet::pen
                 \brief Defines the pen used by the bar set.
             */
             /*!
                 \property QBarSet::brush
                 \brief Defines the brush used by the bar set.
             */
             /*!
                 \qmlproperty QString BarSet::brushFilename
                 The name of the file used as a brush for the set.
             */
             /*!
                 \property QBarSet::labelBrush
                 \brief Defines the brush used by the bar set's label.
             */
             /*!
                 \property QBarSet::labelFont
                 \brief Defines the font used by the bar set's label.
             */
             /*!
                 \qmlproperty Font BarSet::labelFont
                 Defines the font used by the bar set's label.
                 See the Qt documentation for more details of Font.
             */
             /*!
                 \property QBarSet::color
                 The fill (brush) color of the bar set.
             */
             /*!
                 \qmlproperty color BarSet::color
                 The fill (brush) color of the bar set.
             */
             /*!
                 \property QBarSet::borderColor
                 The line (pen) color of the bar set.
             */
             /*!
                 \qmlproperty color BarSet::borderColor
                 The line (pen) color of the bar set.
             */
             /*!
                 \qmlproperty real BarSet::borderWidth
                 The width of the border line. By default the width is 2.0.
             */
             /*!
                 \property QBarSet::labelColor
                 The text (label) color of the bar set.
             */
             /*!
                 \qmlproperty color BarSet::labelColor
                 The text (label) color of the bar set.
             */
             /*!
                 \fn void QBarSet::clicked(int index)
                 The signal is emitted if the user clicks with a mouse on top of bar set.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \fn void QBarSet::pressed(int index)
                 The signal is emitted if the user presses with a mouse on top of bar set.
                 Pressed bar inside set is indexed by \a index
             */
             /*!
                 \fn void QBarSet::released(int index)
                 The signal is emitted if the user releases with a mouse on top of bar set.
                 Released bar inside set is indexed by \a index
             */
             /*!
                 \fn void QBarSet::doubleClicked(int index)
                 The signal is emitted if the user doubleclicks with a mouse on top of bar set.
                 Doubleclicked bar inside set is indexed by \a index
             */
             /*!
                 \fn void QBarSet::hovered(bool status, int index)
                 The signal is emitted if mouse is hovered on top of bar set.
                 Parameter \a status is true, if mouse entered on top of bar set, false if mouse left from top of bar set.
                 Hovered bar inside the set is indexed by \a index.
             */
             /*!
                 \fn void QBarSet::labelChanged()
                 This signal is emitted when the label of the bar set has changed.
                 \sa label
             */
             /*!
                 \qmlsignal BarSet::onLabelChanged()
                 This signal is emitted when the label of the bar set has changed.
             */
             /*!
                 \fn void QBarSet::penChanged()
                 This signal is emitted when the pen of the bar set has changed.
                 \sa pen
             */
             /*!
                 \fn void QBarSet::brushChanged()
                 This signal is emitted when the brush of the bar set has changed.
                 \sa brush
             */
             /*!
                 \fn void QBarSet::labelBrushChanged()
                 This signal is emitted when the brush of the bar set's label has changed.
                 \sa labelBrush
             */
             /*!
                 \fn void QBarSet::labelFontChanged()
                 This signal is emitted when the font of the bar set's label has changed.
                 \sa labelBrush
             */
             /*!
                 \fn void QBarSet::colorChanged(QColor)
                 This signal is emitted when the fill (brush) color of the set has changed to \a color.
             */
             /*!
                 \qmlsignal BarSet::onColorChanged(color color)
                 This signal is emitted when the fill (brush) color of the set has changed to \a color.
             */
             /*!
                 \fn void QBarSet::borderColorChanged(QColor)
                 This signal is emitted when the line (pen) color of the set has changed to \a color.
             */
             /*!
                 \qmlsignal BarSet::onBorderColorChanged(color color)
                 This signal is emitted when the line (pen) color of the set has changed to \a color.
             */
             /*!
                 \fn void QBarSet::labelColorChanged(QColor)
                 This signal is emitted when the text (label) color of the set has changed to \a color.
             */
             /*!
                 \qmlsignal BarSet::onLabelColorChanged(color color)
                 This signal is emitted when the text (label) color of the set has changed to \a color.
             */
             /*!
                 \fn void QBarSet::valuesAdded(int index, int count)
                 This signal is emitted when new values have been added to the set.
                 Parameter \a index indicates the position of the first inserted value.
                 Parameter \a count is the number of inserted values.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal BarSet::onValuesAdded(int index, int count)
                 This signal is emitted when new values have been added to the set.
                 Parameter \a index indicates the position of the first inserted value.
                 Parameter \a count is the number of inserted values.
             */
             /*!
                 \fn void QBarSet::valuesRemoved(int index, int count)
                 This signal is emitted values have been removed from the set.
                 Parameter \a index indicates the position of the first removed value.
                 Parameter \a count is the number of removed values.
                 \sa remove()
             */
             /*!
                 \qmlsignal BarSet::onValuesRemoved(int index, int count)
                 This signal is emitted values have been removed from the set.
                 Parameter \a index indicates the position of the first removed value.
                 Parameter \a count is the number of removed values.
             */
             /*!
                 \fn void QBarSet::valueChanged(int index)
                 This signal is emitted values the value in the set has been modified.
                 Parameter \a index indicates the position of the modified value.
                 \sa at()
             */
             /*!
                 \qmlsignal BarSet::onValueChanged(int index)
                 This signal is emitted values the value in the set has been modified.
                 Parameter \a index indicates the position of the modified value.
             */
             /*!
                 \qmlproperty int BarSet::count
                 The count of values on the bar set
             */
             /*!
                 \qmlproperty QVariantList BarSet::values
                 The values of the bar set. You can set either a list of reals or a list of points as values. If you set a list of
                 reals as values, the values are automatically completed to points by using the index of a value as it's
                 x-coordinate. For example the following sets have equal values:
                 \code
                     myBarSet1.values = [0, 5, 1, 5];
                     myBarSet2.values = [Qt.point(0, 0), Qt.point(1, 5), Qt.point(2, 1), Qt.point(3, 5)];
                 \endcode
             */
             /*!
                 Constructs QBarSet with a label of \a label and with parent of \a parent.
             */
             QBarSet::QBarSet(const QString label, QObject *parent)
                 : QObject(parent),
                   d_ptr(new QBarSetPrivate(label, this))
             {
             }
             /*!
                 Destroys the bar set.
             */
             QBarSet::~QBarSet()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
                 Sets new \a label for set.
             */
             void QBarSet::setLabel(const QString label)
             {
                 d_ptr->m_label = label;
                 emit labelChanged();
             }
             /*!
                 Returns label of the set.
             */
             QString QBarSet::label() const
             {
                 return d_ptr->m_label;
             }
             /*!
                 Appends new value \a value to the end of set.
             */
             void QBarSet::append(const qreal value)
             {
                 // Convert to QPointF
                 int index = d_ptr->m_values.count();
                 d_ptr->append(QPointF(d_ptr->m_values.count(), value));
                 emit valuesAdded(index, 1);
             }
             /*!
                 Appends a list of reals to set. Works like append with single real value. The \a values in list
                 are appended to end of bar set.
                 \sa append()
             */
             void QBarSet::append(const QList<qreal> &values)
             {
                 int index = d_ptr->m_values.count();
                 d_ptr->append(values);
                 emit valuesAdded(index, values.count());
             }
             /*!
                 Convenience operator. Same as append, with real \a value.
                 \sa append()
             */
             QBarSet &QBarSet::operator << (const qreal &value)
             {
                 append(value);
                 return *this;
             }
             /*!
                 Inserts new \a value on the \a index position.
                 The value that is currently at this postion is moved to position index + 1
                 \sa remove()
             */
             void QBarSet::insert(const int index, const qreal value)
             {
                 d_ptr->insert(index, value);
                 emit valuesAdded(index, 1);
             }
             /*!
                 Removes \a count number of values from the set starting at \a index.
                 \sa insert()
             */
             void QBarSet::remove(const int index, const int count)
             {
                 int removedCount = d_ptr->remove(index, count);
                 if (removedCount > 0)
                     emit valuesRemoved(index, removedCount);
                 return;
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index.
             */
             void QBarSet::replace(const int index, const qreal value)
             {
                 if (index >= 0 && index < d_ptr->m_values.count()) {
                     d_ptr->replace(index, value);
                     emit valueChanged(index);
                 }
             }
             /*!
                 Returns value of set indexed by \a index.
                 If the index is out of bounds 0.0 is returned.
             */
             qreal QBarSet::at(const int index) const
             {
                 if (index < 0 || index >= d_ptr->m_values.count())
                     return 0;
                 return d_ptr->m_values.at(index).y();
             }
             /*!
                 Returns value of set indexed by \a index.
                 If the index is out of bounds 0.0 is returned.
             */
             qreal QBarSet::operator [](const int index) const
             {
                 return at(index);
             }
             /*!
                 Returns count of values in set.
             */
             int QBarSet::count() const
             {
                 return d_ptr->m_values.count();
             }
             /*!
                 Returns sum of all values in the bar set.
             */
             qreal QBarSet::sum() const
             {
                 qreal total(0);
                 for (int i = 0; i < d_ptr->m_values.count(); i++)
                     total += d_ptr->m_values.at(i).y();
                 return total;
             }
             /*!
                 Sets pen for set. Bars of this set are drawn using \a pen
             */
             void QBarSet::setPen(const QPen &pen)
             {
                 if (d_ptr->m_pen != pen) {
                     d_ptr->m_pen = pen;
                     emit d_ptr->updatedBars();
                     emit penChanged();
                 }
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBarSet::pen() const
             {
                 if (d_ptr->m_pen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_pen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush.
             */
             void QBarSet::setBrush(const QBrush &brush)
             {
                 if (d_ptr->m_brush != brush) {
                     d_ptr->m_brush = brush;
                     emit d_ptr->updatedBars();
                     emit brushChanged();
                 }
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush() const
             {
                 if (d_ptr->m_brush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d_ptr->m_brush;
             }
             /*!
                 Sets \a brush of the values that are drawn on top of this bar set.
             */
             void QBarSet::setLabelBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelBrush != brush) {
                     d_ptr->m_labelBrush = brush;
                     emit d_ptr->updatedBars();
                     emit labelBrushChanged();
                 }
             }
             /*!
                 Returns brush of the values that are drawn on top of this bar set.
             */
             QBrush QBarSet::labelBrush() const
             {
                 if (d_ptr->m_labelBrush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d_ptr->m_labelBrush;
             }
             /*!
                 Sets the \a font for values that are drawn on top of this bar set.
             */
             void QBarSet::setLabelFont(const QFont &font)
             {
                 if (d_ptr->m_labelFont != font) {
                     d_ptr->m_labelFont = font;
                     emit d_ptr->updatedBars();
                     emit labelFontChanged();
                 }
             }
             /*!
                 Returns the pen for values that are drawn on top of this bar set.
             */
             QFont QBarSet::labelFont() const
             {
                 return d_ptr->m_labelFont;
             }
             /*!
                 Returns the color of the brush of bar set.
             */
             QColor QBarSet::color()
             {
                 return brush().color();
             }
             /*!
                 Sets the \a color of brush for this bar set.
             */
             void QBarSet::setColor(QColor color)
             {
                 QBrush b = brush();
                 if ((b.color() != color) || (b.style() == Qt::NoBrush)) {
                     b.setColor(color);
                     if (b.style() == Qt::NoBrush) {
                         // Set tyle to Qt::SolidPattern. (Default is Qt::NoBrush)
                         // This prevents theme to override color defined in QML side:
                         // BarSet { label: "Bob"; color:"red"; values: [1,2,3] }
                         // The color must be obeyed, since user wanted it.
                         b.setStyle(Qt::SolidPattern);
                     }
                     setBrush(b);
                     emit colorChanged(color);
                 }
             }
             /*!
                 Returns the color of pen of this bar set.
             */
             QColor QBarSet::borderColor()
             {
                 return pen().color();
             }
             /*!
-                Sets the color of pen for this bar set.
+                Sets the \a color of pen for this bar set.
             */
             void QBarSet::setBorderColor(QColor color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             /*!
                 Returns the color of labels of this bar set.
             */
             QColor QBarSet::labelColor()
             {
                 return labelBrush().color();
             }
             /*!
-                Sets the color of labels for this bar set.
+                Sets the \a color of labels for this bar set.
             */
             void QBarSet::setLabelColor(QColor color)
             {
                 QBrush b = labelBrush();
                 if (b == QBrush())
                     b.setStyle(Qt::SolidPattern);
                 if (d_ptr->m_labelBrush.color() != color) {
                     b.setColor(color);
                     setLabelBrush(b);
                     emit labelColorChanged(color);
                 }
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSetPrivate::QBarSetPrivate(const QString label, QBarSet *parent) : QObject(parent),
                 q_ptr(parent),
                 m_label(label),
                 m_pen(QChartPrivate::defaultPen()),
                 m_brush(QChartPrivate::defaultBrush()),
                 m_labelBrush(QChartPrivate::defaultBrush())
             {
             }
             QBarSetPrivate::~QBarSetPrivate()
             {
             }
             void QBarSetPrivate::append(QPointF value)
             {
                 if (isValidValue(value)) {
                     m_values.append(value);
                     emit restructuredBars();
                 }
             }
             void QBarSetPrivate::append(QList<QPointF> values)
             {
                 for (int i = 0; i < values.count(); i++) {
                     if (isValidValue(values.at(i)))
                         m_values.append(values.at(i));
                 }
                 emit restructuredBars();
             }
             void QBarSetPrivate::append(QList<qreal> values)
             {
                 int index = m_values.count();
                 for (int i = 0; i < values.count(); i++) {
                     if (isValidValue(values.at(i))) {
                         m_values.append(QPointF(index, values.at(i)));
                         index++;
                     }
                 }
                 emit restructuredBars();
             }
             void QBarSetPrivate::insert(const int index, const qreal value)
             {
                 m_values.insert(index, QPointF(index, value));
                 emit restructuredBars();
             }
             void QBarSetPrivate::insert(const int index, const QPointF value)
             {
                 m_values.insert(index, value);
                 emit restructuredBars();
             }
             int QBarSetPrivate::remove(const int index, const int count)
             {
                 int removeCount = count;
                 if ((index < 0) || (m_values.count() == 0))
                     return 0; // Invalid index or not values in list, remove nothing.
                 else if ((index + count) > m_values.count())
                     removeCount = m_values.count() - index; // Trying to remove more items than list has. Limit amount to be removed.
                 int c = 0;
                 while (c < removeCount) {
                     m_values.removeAt(index);
                     c++;
                 }
                 emit restructuredBars();
                 return removeCount;
             }
             void QBarSetPrivate::replace(const int index, const qreal value)
             {
                 m_values.replace(index, QPointF(index, value));
                 emit updatedLayout();
             }
             void QBarSetPrivate::replace(const int index, const QPointF value)
             {
                 m_values.replace(index, value);
                 emit updatedLayout();
             }
             qreal QBarSetPrivate::pos(const int index)
             {
                 if (index < 0 || index >= m_values.count())
                     return 0;
                 return m_values.at(index).x();
             }
             qreal QBarSetPrivate::value(const int index)
             {
                 if (index < 0 || index >= m_values.count())
                     return 0;
                 return m_values.at(index).y();
             }
             #include "moc_qbarset.cpp"
             #include "moc_qbarset_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/chartdataset.cpp +9 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/chartdataset_p.h>
             #include <private/chartpresenter_p.h>
             #include <QtCharts/QChart>
             #include <private/qchart_p.h>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QBarCategoryAxis>
             #include <private/qvalueaxis_p.h>
             #include <QtCharts/QCategoryAxis>
             #include <private/qabstractseries_p.h>
             #include <QtCharts/QAbstractBarSeries>
             #include <QtCharts/QStackedBarSeries>
             #include <QtCharts/QPercentBarSeries>
             #include <QtCharts/QPieSeries>
             #include <private/chartitem_p.h>
             #include <private/xydomain_p.h>
             #include <private/xypolardomain_p.h>
             #include <private/xlogydomain_p.h>
             #include <private/logxydomain_p.h>
             #include <private/logxlogydomain_p.h>
             #include <private/xlogypolardomain_p.h>
             #include <private/logxypolardomain_p.h>
             #include <private/logxlogypolardomain_p.h>
+            #include <private/glxyseriesdata_p.h>
             #ifndef QT_ON_ARM
             #include <QtCharts/QDateTimeAxis>
             #endif
             QT_CHARTS_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QChart *chart)
                 : QObject(chart),
-                  m_chart(chart)
+                  m_chart(chart),
+                  m_glXYSeriesDataManager(new GLXYSeriesDataManager(this))
             {
             }
             ChartDataSet::~ChartDataSet()
             {
                 deleteAllSeries();
                 deleteAllAxes();
             }
             /*
              * This method adds series to chartdataset, series ownership is taken from caller.
              */
             void ChartDataSet::addSeries(QAbstractSeries *series)
             {
                 if (m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not add series. Series already on the chart.");
                     return;
                 }
                 // Ignore unsupported series added to polar chart
                 if (m_chart && m_chart->chartType() == QChart::ChartTypePolar) {
                     if (!(series->type() == QAbstractSeries::SeriesTypeArea
                         || series->type() == QAbstractSeries::SeriesTypeLine
                         || series->type() == QAbstractSeries::SeriesTypeScatter
                         || series->type() == QAbstractSeries::SeriesTypeSpline)) {
                         qWarning() << QObject::tr("Can not add series. Series type is not supported by a polar chart.");
                         return;
                     }
+                    // Disable OpenGL for series in polar charts
+                    series->setUseOpenGL(false);
                     series->d_ptr->setDomain(new XYPolarDomain());
                     // Set the correct domain for upper and lower series too
                     if (series->type() == QAbstractSeries::SeriesTypeArea) {
                         foreach (QObject *child, series->children()) {
                             if (qobject_cast<QAbstractSeries *>(child)) {
                                 QAbstractSeries *childSeries = qobject_cast<QAbstractSeries *>(child);
                                 childSeries->d_ptr->setDomain(new XYPolarDomain());
                             }
                         }
                     }
                 } else {
                     series->d_ptr->setDomain(new XYDomain());
                 }
                 series->d_ptr->initializeDomain();
                 m_seriesList.append(series);
                 series->setParent(this); // take ownership
                 series->d_ptr->m_chart = m_chart;
                 emit seriesAdded(series);
             }
             /*
              * This method adds axis to chartdataset, axis ownership is taken from caller.
              */
             void ChartDataSet::addAxis(QAbstractAxis *axis, Qt::Alignment aligment)
             {
                 if (m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not add axis. Axis already on the chart.");
                     return;
                 }
                 axis->d_ptr->setAlignment(aligment);
                 if (!axis->alignment()) {
                     qWarning() << QObject::tr("No alignment specified !");
                     return;
                 };
                 AbstractDomain *newDomain;
                 if (m_chart && m_chart->chartType() == QChart::ChartTypePolar)
                     newDomain = new XYPolarDomain();
                 else
                     newDomain = new XYDomain();
                 QSharedPointer<AbstractDomain> domain(newDomain);
                 axis->d_ptr->initializeDomain(domain.data());
                 axis->setParent(this);
                 axis->d_ptr->m_chart = m_chart;
                 m_axisList.append(axis);
                 emit axisAdded(axis);
             }
             /*
              * This method removes series form chartdataset, series ownership is passed back to caller.
              */
             void ChartDataSet::removeSeries(QAbstractSeries *series)
             {
                 if (! m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not remove series. Series not found on the chart.");
                     return;
                 }
                 QList<QAbstractAxis*> axes = series->d_ptr->m_axes;
                 foreach(QAbstractAxis* axis, axes) {
                     detachAxis(series,axis);
                 }
                 emit seriesRemoved(series);
                 m_seriesList.removeAll(series);
                 // Reset domain to default
                 series->d_ptr->setDomain(new XYDomain());
                 series->setParent(0);
                 series->d_ptr->m_chart = 0;
+                QXYSeries *xySeries = qobject_cast<QXYSeries *>(series);
+                if (xySeries)
+                    m_glXYSeriesDataManager->removeSeries(xySeries);
             }
             /*
              * This method removes axis form chartdataset, series ownership is passed back to caller.
              */
             void ChartDataSet::removeAxis(QAbstractAxis *axis)
             {
                 if (! m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not remove axis. Axis not found on the chart.");
                     return;
                 }
                 QList<QAbstractSeries*> series =  axis->d_ptr->m_series;
                 foreach(QAbstractSeries* s, series) {
                   detachAxis(s,axis);
                 }
                 emit axisRemoved(axis);
                 m_axisList.removeAll(axis);
                 axis->setParent(0);
                 axis->d_ptr->m_chart = 0;
             }
             /*
              * This method attaches axis to series, return true if success.
              */
             bool ChartDataSet::attachAxis(QAbstractSeries *series,QAbstractAxis *axis)
             {
                 Q_ASSERT(axis);
                 if (!series)
                     return false;
                 QList<QAbstractSeries *> attachedSeriesList = axis->d_ptr->m_series;
                 QList<QAbstractAxis *> attachedAxisList = series->d_ptr->m_axes;
                 if (!m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not find series on the chart.");
                     return false;
                 }
                 if (axis && !m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not find axis on the chart.");
                     return false;
                 }
                 if (attachedAxisList.contains(axis)) {
                     qWarning() << QObject::tr("Axis already attached to series.");
                     return false;
                 }
                 if (attachedSeriesList.contains(series)) {
                     qWarning() << QObject::tr("Axis already attached to series.");
                     return false;
                 }
                 AbstractDomain *domain = series->d_ptr->domain();
                 AbstractDomain::DomainType type = selectDomain(attachedAxisList<<axis);
                 if (type == AbstractDomain::UndefinedDomain) return false;
                 if (domain->type() != type) {
                     AbstractDomain *old = domain;
                     domain = createDomain(type);
                     domain->setRange(old->minX(), old->maxX(), old->minY(), old->maxY());
                     // Initialize domain size to old domain size, as it won't get updated
                     // unless geometry changes.
                     domain->setSize(old->size());
                 }
                 if (!domain)
                     return false;
                 if (!domain->attachAxis(axis))
                     return false;
                 QList<AbstractDomain *> blockedDomains;
                 domain->blockRangeSignals(true);
                 blockedDomains << domain;
                 if (domain != series->d_ptr->domain()) {
                     foreach (QAbstractAxis *axis, series->d_ptr->m_axes) {
                         series->d_ptr->domain()->detachAxis(axis);
                         domain->attachAxis(axis);
                         foreach (QAbstractSeries *otherSeries, axis->d_ptr->m_series) {
                             if (otherSeries != series && otherSeries->d_ptr->domain()) {
                                 if (!otherSeries->d_ptr->domain()->rangeSignalsBlocked()) {
                                     otherSeries->d_ptr->domain()->blockRangeSignals(true);
                                     blockedDomains << otherSeries->d_ptr->domain();
                                 }
                             }
                         }
                     }
                     series->d_ptr->setDomain(domain);
                     series->d_ptr->initializeDomain();
                 }
                 series->d_ptr->m_axes<<axis;
                 axis->d_ptr->m_series<<series;
                 series->d_ptr->initializeAxes();
                 axis->d_ptr->initializeDomain(domain);
                 foreach (AbstractDomain *blockedDomain, blockedDomains)
                     blockedDomain->blockRangeSignals(false);
                 return true;
             }
             /*
              * This method detaches axis to series, return true if success.
              */
             bool ChartDataSet::detachAxis(QAbstractSeries* series,QAbstractAxis *axis)
             {
                 Q_ASSERT(series);
                 Q_ASSERT(axis);
                 QList<QAbstractSeries* > attachedSeriesList = axis->d_ptr->m_series;
                 QList<QAbstractAxis* > attachedAxisList = series->d_ptr->m_axes;
                 AbstractDomain* domain =  series->d_ptr->domain();
                 if (!m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not find series on the chart.");
                     return false;
                 }
                 if (axis && !m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not find axis on the chart.");
                     return false;
                 }
                 if (!attachedAxisList.contains(axis)) {
                     qWarning() << QObject::tr("Axis not attached to series.");
                     return false;
                 }
                 Q_ASSERT(axis->d_ptr->m_series.contains(series));
                 domain->detachAxis(axis);
                 series->d_ptr->m_axes.removeAll(axis);
                 axis->d_ptr->m_series.removeAll(series);
                 return true;
             }
             void ChartDataSet::createDefaultAxes()
             {
                 if (m_seriesList.isEmpty())
                     return;
                 QAbstractAxis::AxisTypes typeX(0);
                 QAbstractAxis::AxisTypes typeY(0);
                 // Remove possibly existing axes
                 deleteAllAxes();
                 Q_ASSERT(m_axisList.isEmpty());
                 // Select the required axis x and axis y types based on the types of the current series
                 foreach(QAbstractSeries* s, m_seriesList) {
                     typeX |= s->d_ptr->defaultAxisType(Qt::Horizontal);
                     typeY |= s->d_ptr->defaultAxisType(Qt::Vertical);
                 }
                 createAxes(typeX, Qt::Horizontal);
                 createAxes(typeY, Qt::Vertical);
             }
             void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation)
             {
                 QAbstractAxis *axis = 0;
                 //decide what axis should be created
                 switch (type) {
                     case QAbstractAxis::AxisTypeValue:
                     axis = new QValueAxis(this);
                     break;
                     case QAbstractAxis::AxisTypeBarCategory:
                     axis = new QBarCategoryAxis(this);
                     break;
                     case QAbstractAxis::AxisTypeCategory:
                     axis = new QCategoryAxis(this);
                     break;
             #ifndef Q_WS_QWS
                     case QAbstractAxis::AxisTypeDateTime:
                     axis = new QDateTimeAxis(this);
                     break;
             #endif
                     default:
                     axis = 0;
                     break;
                 }
                 if (axis) {
                     //create one axis for all
                     addAxis(axis,orientation==Qt::Horizontal?Qt::AlignBottom:Qt::AlignLeft);
                     qreal min = 0;
                     qreal max = 0;
                     findMinMaxForSeries(m_seriesList,orientation,min,max);
                     foreach(QAbstractSeries *s, m_seriesList) {
                         attachAxis(s,axis);
                     }
                     axis->setRange(min,max);
                 } else {
                     // Create separate axis for each series
                     foreach(QAbstractSeries *s, m_seriesList) {
                         QAbstractAxis *axis = s->d_ptr->createDefaultAxis(orientation);
                         if(axis) {
                             addAxis(axis,orientation==Qt::Horizontal?Qt::AlignBottom:Qt::AlignLeft);
                             attachAxis(s,axis);
                         }
                     }
                 }
             }
             void ChartDataSet::findMinMaxForSeries(QList<QAbstractSeries *> series,Qt::Orientations orientation, qreal &min, qreal &max)
             {
                 Q_ASSERT(!series.isEmpty());
                 AbstractDomain *domain = series.first()->d_ptr->domain();
                 min = (orientation == Qt::Vertical) ? domain->minY() : domain->minX();
                 max = (orientation == Qt::Vertical) ? domain->maxY() : domain->maxX();
                 for (int i = 1; i< series.size(); i++) {
                     AbstractDomain *domain = series[i]->d_ptr->domain();
                     min = qMin((orientation == Qt::Vertical) ? domain->minY() : domain->minX(), min);
                     max = qMax((orientation == Qt::Vertical) ? domain->maxY() : domain->maxX(), max);
                 }
                 if (min == max) {
                     min -= 0.5;
                     max += 0.5;
                 }
             }
             void ChartDataSet::deleteAllSeries()
             {
                 foreach (QAbstractSeries *s , m_seriesList){
                     removeSeries(s);
                     s->deleteLater();
                 }
                 Q_ASSERT(m_seriesList.count() == 0);
             }
             void ChartDataSet::deleteAllAxes()
             {
                 foreach (QAbstractAxis *a , m_axisList){
                     removeAxis(a);
                     a->deleteLater();
                 }
                 Q_ASSERT(m_axisList.count() == 0);
             }
             void ChartDataSet::zoomInDomain(const QRectF &rect)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomIn(rect);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             void ChartDataSet::zoomOutDomain(const QRectF &rect)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomOut(rect);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             void ChartDataSet::zoomResetDomain()
             {
                 QList<AbstractDomain*> domains;
                 foreach (QAbstractSeries *s, m_seriesList) {
                     AbstractDomain *domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains << domain;
                 }
                 foreach (AbstractDomain *domain, domains)
                     domain->zoomReset();
                 foreach (AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             bool ChartDataSet::isZoomedDomain()
             {
                 foreach (QAbstractSeries *s, m_seriesList) {
                     if (s->d_ptr->domain()->isZoomed())
                         return true;
                 }
                 return false;
             }
             void ChartDataSet::scrollDomain(qreal dx, qreal dy)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->move(dx, dy);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             QPointF ChartDataSet::mapToValue(const QPointF &position, QAbstractSeries *series)
             {
                 QPointF point;
                 if (series == 0 && !m_seriesList.isEmpty())
                     series = m_seriesList.first();
                 if (series && series->type() == QAbstractSeries::SeriesTypePie)
                     return point;
                 if (series && m_seriesList.contains(series))
                     point = series->d_ptr->m_domain->calculateDomainPoint(position - m_chart->plotArea().topLeft());
                 return point;
             }
             QPointF ChartDataSet::mapToPosition(const QPointF &value, QAbstractSeries *series)
             {
                 QPointF point = m_chart->plotArea().topLeft();
                 if (series == 0 && !m_seriesList.isEmpty())
                     series = m_seriesList.first();
                 if (series && series->type() == QAbstractSeries::SeriesTypePie)
                     return QPoint(0, 0);
                 bool ok;
                 if (series && m_seriesList.contains(series))
                     point += series->d_ptr->m_domain->calculateGeometryPoint(value, ok);
                 return point;
             }
             QList<QAbstractAxis *> ChartDataSet::axes() const
             {
                return m_axisList;
             }
             QList<QAbstractSeries *> ChartDataSet::series() const
             {
                 return m_seriesList;
             }
             AbstractDomain::DomainType ChartDataSet::selectDomain(QList<QAbstractAxis *> axes)
             {
                 enum Type {
                     Undefined = 0,
                     LogType = 0x1,
                     ValueType = 0x2
                 };
                 int horizontal(Undefined);
                 int vertical(Undefined);
                 // Assume cartesian chart type, unless chart is set
                 QChart::ChartType chartType(QChart::ChartTypeCartesian);
                 if (m_chart)
                     chartType = m_chart->chartType();
                 foreach (QAbstractAxis *axis, axes)
                 {
                     switch (axis->type()) {
                     case QAbstractAxis::AxisTypeLogValue:
                         if (axis->orientation() == Qt::Horizontal)
                             horizontal |= LogType;
                         if (axis->orientation() == Qt::Vertical)
                             vertical |= LogType;
                         break;
                     case QAbstractAxis::AxisTypeValue:
                     case QAbstractAxis::AxisTypeBarCategory:
                     case QAbstractAxis::AxisTypeCategory:
                     case QAbstractAxis::AxisTypeDateTime:
                         if (axis->orientation() == Qt::Horizontal)
                             horizontal |= ValueType;
                         if (axis->orientation() == Qt::Vertical)
                             vertical |= ValueType;
                         break;
                     default:
                         qWarning() << "Undefined type";
                         break;
                     }
                 }
                 if (vertical == Undefined)
                     vertical = ValueType;
                 if (horizontal == Undefined)
                     horizontal = ValueType;
                 if (vertical == ValueType && horizontal == ValueType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::XYDomain;
                     else if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::XYPolarDomain;
                 }
                 if (vertical == LogType && horizontal == ValueType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::XLogYDomain;
                     if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::XLogYPolarDomain;
                 }
                 if (vertical == ValueType && horizontal == LogType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::LogXYDomain;
                     else if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::LogXYPolarDomain;
                 }
                 if (vertical == LogType && horizontal == LogType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::LogXLogYDomain;
                     else if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::LogXLogYPolarDomain;
                 }
                 return AbstractDomain::UndefinedDomain;
             }
             //refactor create factory
             AbstractDomain* ChartDataSet::createDomain(AbstractDomain::DomainType type)
             {
                 switch (type)
                 {
                 case AbstractDomain::LogXLogYDomain:
                     return new LogXLogYDomain();
                 case AbstractDomain::XYDomain:
                     return new XYDomain();
                 case AbstractDomain::XLogYDomain:
                     return new XLogYDomain();
                 case AbstractDomain::LogXYDomain:
                     return new LogXYDomain();
                 case AbstractDomain::XYPolarDomain:
                     return new XYPolarDomain();
                 case AbstractDomain::XLogYPolarDomain:
                     return new XLogYPolarDomain();
                 case AbstractDomain::LogXYPolarDomain:
                     return new LogXYPolarDomain();
                 case AbstractDomain::LogXLogYPolarDomain:
                     return new LogXLogYPolarDomain();
                 default:
                     return 0;
                 }
             }
             #include "moc_chartdataset_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/chartdataset_p.h +4 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 CHARTDATASET_P_H
             #define CHARTDATASET_P_H
             #include <QtCharts/QAbstractSeries>
             #include <private/abstractdomain_p.h>
             #include <private/qabstractaxis_p.h>
             #include <QtCore/QVector>
             QT_CHARTS_BEGIN_NAMESPACE
             class QAbstractAxis;
             class ChartPresenter;
+            class GLXYSeriesDataManager;
             class QT_CHARTS_AUTOTEST_EXPORT ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
                 ChartDataSet(QChart *chart);
                 virtual ~ChartDataSet();
                 void addSeries(QAbstractSeries *series);
                 void removeSeries(QAbstractSeries *series);
                 QList<QAbstractSeries *> series() const;
                 void addAxis(QAbstractAxis *axis,Qt::Alignment aligment);
                 void removeAxis(QAbstractAxis *axis);
                 QList<QAbstractAxis*> axes() const;
                 bool attachAxis(QAbstractSeries* series,QAbstractAxis *axis);
                 bool detachAxis(QAbstractSeries* series,QAbstractAxis *axis);
                 void createDefaultAxes();
                 void zoomInDomain(const QRectF &rect);
                 void zoomOutDomain(const QRectF &rect);
                 void zoomResetDomain();
                 bool isZoomedDomain();
                 void scrollDomain(qreal dx, qreal dy);
                 QPointF mapToValue(const QPointF &position, QAbstractSeries *series = 0);
                 QPointF mapToPosition(const QPointF &value, QAbstractSeries *series = 0);
+                GLXYSeriesDataManager *glXYSeriesDataManager() { return m_glXYSeriesDataManager; }
             Q_SIGNALS:
                 void axisAdded(QAbstractAxis* axis);
                 void axisRemoved(QAbstractAxis* axis);
                 void seriesAdded(QAbstractSeries* series);
                 void seriesRemoved(QAbstractSeries* series);
             private:
                 void createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation);
                 QAbstractAxis *createAxis(QAbstractAxis::AxisType type, Qt::Orientation orientation);
                 AbstractDomain::DomainType selectDomain(QList<QAbstractAxis* > axes);
                 AbstractDomain* createDomain(AbstractDomain::DomainType type);
                 void deleteAllAxes();
                 void deleteAllSeries();
                 void findMinMaxForSeries(QList<QAbstractSeries *> series,Qt::Orientations orientation, qreal &min, qreal &max);
             private:
                 QList<QAbstractSeries *> m_seriesList;
                 QList<QAbstractAxis *> m_axisList;
                 QChart* m_chart;
+                GLXYSeriesDataManager *m_glXYSeriesDataManager;
             };
             QT_CHARTS_END_NAMESPACE
             #endif /* CHARTENGINE_P_H */

src/charts/chartelement.cpp +13 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/chartelement_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/abstractdomain_p.h>
+            #include <private/chartdataset_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             ChartElement::ChartElement(QGraphicsItem* item):
                   QGraphicsObject(item),
                   m_presenter(0),
-                  m_themeManager(0)
+                  m_themeManager(0),
+                  m_dataSet(0)
             {
             }
             void ChartElement::setPresenter(ChartPresenter *presenter)
             {
                 m_presenter = presenter;
             }
             ChartPresenter *ChartElement::presenter() const
             {
                 return m_presenter;
             }
             void ChartElement::setThemeManager(ChartThemeManager *manager)
             {
                 m_themeManager = manager;
             }
             ChartThemeManager* ChartElement::themeManager() const
             {
                 return m_themeManager;
             }
+            void ChartElement::setDataSet(ChartDataSet *dataSet)
+            {
+                m_dataSet = dataSet;
+            }
+            ChartDataSet *ChartElement::dataSet() const
+            {
+                return m_dataSet;
+            }
             QT_CHARTS_END_NAMESPACE

src/charts/chartelement_p.h +4 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 CHARTELEMENT_H
             #define CHARTELEMENT_H
             #include <QtCharts/QChartGlobal>
             #include <QtCore/QObject>
             #include <QtCore/QRect>
             #include <QGraphicsObject>
             QT_CHARTS_BEGIN_NAMESPACE
             class ChartAnimator;
             class ChartPresenter;
             class ChartAnimation;
             class ChartThemeManager;
             class AbstractDomain;
+            class ChartDataSet;
             class ChartElement: public QGraphicsObject
             {
             public:
                 explicit ChartElement(QGraphicsItem* item = 0);
                 virtual ChartAnimation *animation() const { return 0; }
                 virtual void setPresenter(ChartPresenter *presenter);
                 ChartPresenter *presenter() const;
                 virtual void setThemeManager(ChartThemeManager *manager);
                 ChartThemeManager* themeManager() const;
+                virtual void setDataSet(ChartDataSet *dataSet);
+                ChartDataSet *dataSet() const;
             private:
                 ChartPresenter *m_presenter;
                 ChartThemeManager *m_themeManager;
+                ChartDataSet *m_dataSet;
             };
             QT_CHARTS_END_NAMESPACE
             #endif

src/charts/chartpresenter.cpp +34 -1

             /****************************************************************************
              **
              ** Copyright (C) 2015 The Qt Company Ltd
              ** All rights reserved.
              ** For any questions to The Qt Company, please use contact form at http://qt.io
              **
              ** This file is part of the Qt Charts module.
              **
              ** Licensees holding valid commercial license for Qt may use this file in
              ** accordance with the Qt License Agreement provided with the Software
              ** or, alternatively, in accordance with the terms contained in a written
              ** agreement between you and The Qt Company.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.io
              **
              ****************************************************************************/
             #include <private/chartpresenter_p.h>
             #include <QtCharts/QChart>
             #include <private/chartitem_p.h>
             #include <private/qchart_p.h>
             #include <QtCharts/QAbstractAxis>
             #include <private/qabstractaxis_p.h>
             #include <private/chartdataset_p.h>
             #include <private/chartanimation_p.h>
             #include <private/qabstractseries_p.h>
             #include <QtCharts/QAreaSeries>
             #include <private/chartaxiselement_p.h>
             #include <private/chartbackground_p.h>
             #include <private/cartesianchartlayout_p.h>
             #include <private/polarchartlayout_p.h>
             #include <private/charttitle_p.h>
             #include <QtCore/QTimer>
             #include <QtGui/QTextDocument>
             QT_CHARTS_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart *chart, QChart::ChartType type)
                 : QObject(chart),
                   m_chart(chart),
                   m_options(QChart::NoAnimation),
                   m_animationDuration(ChartAnimationDuration),
                   m_animationCurve(QEasingCurve::OutQuart),
                   m_state(ShowState),
                   m_background(0),
                   m_plotAreaBackground(0),
                   m_title(0),
                   m_localizeNumbers(false)
+            #ifndef QT_NO_OPENGL
+                  , m_glWidget(0)
+                  , m_glUseWidget(true)
+            #endif
             {
                 if (type == QChart::ChartTypeCartesian)
                     m_layout = new CartesianChartLayout(this);
                 else if (type == QChart::ChartTypePolar)
                     m_layout = new PolarChartLayout(this);
                 Q_ASSERT(m_layout);
             }
             ChartPresenter::~ChartPresenter()
             {
+            #ifndef QT_NO_OPENGL
+                delete m_glWidget.data();
+            #endif
             }
             void ChartPresenter::setGeometry(const QRectF rect)
             {
                 if (m_rect != rect) {
                     m_rect = rect;
                     foreach (ChartItem *chart, m_chartItems) {
                         chart->domain()->setSize(rect.size());
                         chart->setPos(rect.topLeft());
                     }
+            #ifndef QT_NO_OPENGL
+                    if (!m_glWidget.isNull())
+                        m_glWidget->setGeometry(m_rect.toRect());
+            #endif
                     emit plotAreaChanged(m_rect);
                 }
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleAxisAdded(QAbstractAxis *axis)
             {
                 axis->d_ptr->initializeGraphics(rootItem());
                 axis->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                 ChartAxisElement *item = axis->d_ptr->axisItem();
                 item->setPresenter(this);
                 item->setThemeManager(m_chart->d_ptr->m_themeManager);
                 m_axisItems<<item;
                 m_axes<<axis;
                 m_layout->invalidate();
             }
             void ChartPresenter::handleAxisRemoved(QAbstractAxis *axis)
             {
                 ChartAxisElement *item  = axis->d_ptr->m_item.take();
                 item->hide();
                 item->disconnect();
                 item->deleteLater();
                 m_axisItems.removeAll(item);
                 m_axes.removeAll(axis);
                 m_layout->invalidate();
             }
             void ChartPresenter::handleSeriesAdded(QAbstractSeries *series)
             {
                 series->d_ptr->initializeGraphics(rootItem());
                 series->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                 series->d_ptr->setPresenter(this);
                 ChartItem *chart = series->d_ptr->chartItem();
                 chart->setPresenter(this);
                 chart->setThemeManager(m_chart->d_ptr->m_themeManager);
+                chart->setDataSet(m_chart->d_ptr->m_dataset);
                 chart->domain()->setSize(m_rect.size());
                 chart->setPos(m_rect.topLeft());
                 chart->handleDomainUpdated(); //this could be moved to intializeGraphics when animator is refactored
                 m_chartItems<<chart;
                 m_series<<series;
                 m_layout->invalidate();
             }
             void ChartPresenter::handleSeriesRemoved(QAbstractSeries *series)
             {
                 ChartItem *chart  = series->d_ptr->m_item.take();
                 chart->hide();
                 chart->disconnect();
                 chart->deleteLater();
                 if (chart->animation())
                     chart->animation()->stopAndDestroyLater();
                 m_chartItems.removeAll(chart);
                 m_series.removeAll(series);
                 m_layout->invalidate();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if (m_options != options) {
                     QChart::AnimationOptions oldOptions = m_options;
                     m_options = options;
                     if (options.testFlag(QChart::SeriesAnimations) != oldOptions.testFlag(QChart::SeriesAnimations)) {
                         foreach (QAbstractSeries *series, m_series)
                             series->d_ptr->initializeAnimations(m_options, m_animationDuration,
                                                                 m_animationCurve);
                     }
                     if (options.testFlag(QChart::GridAxisAnimations) != oldOptions.testFlag(QChart::GridAxisAnimations)) {
                         foreach (QAbstractAxis *axis, m_axes)
                             axis->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                     }
                     m_layout->invalidate(); // So that existing animations don't just stop halfway
                 }
             }
             void ChartPresenter::setAnimationDuration(int msecs)
             {
                 if (m_animationDuration != msecs) {
                     m_animationDuration = msecs;
                     foreach (QAbstractSeries *series, m_series)
                         series->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                     foreach (QAbstractAxis *axis, m_axes)
                         axis->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                     m_layout->invalidate(); // So that existing animations don't just stop halfway
                 }
             }
             void ChartPresenter::setAnimationEasingCurve(const QEasingCurve &curve)
             {
                 if (m_animationCurve != curve) {
                     m_animationCurve = curve;
                     foreach (QAbstractSeries *series, m_series)
                         series->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                     foreach (QAbstractAxis *axis, m_axes)
                         axis->d_ptr->initializeAnimations(m_options, m_animationDuration, m_animationCurve);
                     m_layout->invalidate(); // So that existing animations don't just stop halfway
                 }
             }
             void ChartPresenter::setState(State state,QPointF point)
             {
             	m_state=state;
             	m_statePoint=point;
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::createBackgroundItem()
             {
                 if (!m_background) {
                     m_background = new ChartBackground(rootItem());
                     m_background->setPen(Qt::NoPen); // Theme doesn't touch pen so don't use default
                     m_background->setBrush(QChartPrivate::defaultBrush());
                     m_background->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createPlotAreaBackgroundItem()
             {
                 if (!m_plotAreaBackground) {
                     if (m_chart->chartType() == QChart::ChartTypeCartesian)
                         m_plotAreaBackground = new QGraphicsRectItem(rootItem());
                     else
                         m_plotAreaBackground = new QGraphicsEllipseItem(rootItem());
                     // Use transparent pen instead of Qt::NoPen, as Qt::NoPen causes
                     // antialising artifacts with axis lines for some reason.
                     m_plotAreaBackground->setPen(QPen(Qt::transparent));
                     m_plotAreaBackground->setBrush(Qt::NoBrush);
                     m_plotAreaBackground->setZValue(ChartPresenter::PlotAreaZValue);
                     m_plotAreaBackground->setVisible(false);
                 }
             }
             void ChartPresenter::createTitleItem()
             {
                 if (!m_title) {
                     m_title = new ChartTitle(rootItem());
                     m_title->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::startAnimation(ChartAnimation *animation)
             {
                 animation->stop();
                 QTimer::singleShot(0, animation, SLOT(startChartAnimation()));
             }
             void ChartPresenter::setBackgroundBrush(const QBrush &brush)
             {
                 createBackgroundItem();
                 m_background->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::backgroundBrush() const
             {
                 if (!m_background)
                     return QBrush();
                 return m_background->brush();
             }
             void ChartPresenter::setBackgroundPen(const QPen &pen)
             {
                 createBackgroundItem();
                 m_background->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::backgroundPen() const
             {
                 if (!m_background)
                     return QPen();
                 return m_background->pen();
             }
             void ChartPresenter::setBackgroundRoundness(qreal diameter)
             {
                 createBackgroundItem();
                 m_background->setDiameter(diameter);
                 m_layout->invalidate();
             }
             qreal ChartPresenter::backgroundRoundness() const
             {
                 if (!m_background)
                     return 0;
                 return m_background->diameter();
             }
             void ChartPresenter::setPlotAreaBackgroundBrush(const QBrush &brush)
             {
                 createPlotAreaBackgroundItem();
                 m_plotAreaBackground->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::plotAreaBackgroundBrush() const
             {
                 if (!m_plotAreaBackground)
                     return QBrush();
                 return m_plotAreaBackground->brush();
             }
             void ChartPresenter::setPlotAreaBackgroundPen(const QPen &pen)
             {
                 createPlotAreaBackgroundItem();
                 m_plotAreaBackground->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::plotAreaBackgroundPen() const
             {
                 if (!m_plotAreaBackground)
                     return QPen();
                 return m_plotAreaBackground->pen();
             }
             void ChartPresenter::setTitle(const QString &title)
             {
                 createTitleItem();
                 m_title->setText(title);
                 m_layout->invalidate();
             }
             QString ChartPresenter::title() const
             {
                 if (!m_title)
                     return QString();
                 return m_title->text();
             }
             void ChartPresenter::setTitleFont(const QFont &font)
             {
                 createTitleItem();
                 m_title->setFont(font);
                 m_layout->invalidate();
             }
             QFont ChartPresenter::titleFont() const
             {
                 if (!m_title)
                     return QFont();
                 return m_title->font();
             }
             void ChartPresenter::setTitleBrush(const QBrush &brush)
             {
                 createTitleItem();
                 m_title->setDefaultTextColor(brush.color());
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::titleBrush() const
             {
                 if (!m_title)
                     return QBrush();
                 return QBrush(m_title->defaultTextColor());
             }
             void ChartPresenter::setBackgroundVisible(bool visible)
             {
                 createBackgroundItem();
                 m_background->setVisible(visible);
             }
             bool ChartPresenter::isBackgroundVisible() const
             {
                 if (!m_background)
                     return false;
                 return m_background->isVisible();
             }
             void ChartPresenter::setPlotAreaBackgroundVisible(bool visible)
             {
                 createPlotAreaBackgroundItem();
                 m_plotAreaBackground->setVisible(visible);
             }
             bool ChartPresenter::isPlotAreaBackgroundVisible() const
             {
                 if (!m_plotAreaBackground)
                     return false;
                 return m_plotAreaBackground->isVisible();
             }
             void ChartPresenter::setBackgroundDropShadowEnabled(bool enabled)
             {
                 createBackgroundItem();
                 m_background->setDropShadowEnabled(enabled);
             }
             bool ChartPresenter::isBackgroundDropShadowEnabled() const
             {
                 if (!m_background)
                     return false;
                 return m_background->isDropShadowEnabled();
             }
             void ChartPresenter::setLocalizeNumbers(bool localize)
             {
                 m_localizeNumbers = localize;
                 m_layout->invalidate();
             }
             void ChartPresenter::setLocale(const QLocale &locale)
             {
                 m_locale = locale;
                 m_layout->invalidate();
             }
             AbstractChartLayout *ChartPresenter::layout()
             {
                 return m_layout;
             }
             QLegend *ChartPresenter::legend()
             {
                 return m_chart->legend();
             }
             void ChartPresenter::setVisible(bool visible)
             {
                 m_chart->setVisible(visible);
             }
             ChartBackground *ChartPresenter::backgroundElement()
             {
                 return m_background;
             }
             QAbstractGraphicsShapeItem *ChartPresenter::plotAreaElement()
             {
                 return m_plotAreaBackground;
             }
             QList<ChartAxisElement *>  ChartPresenter::axisItems() const
             {
                 return m_axisItems;
             }
             QList<ChartItem *> ChartPresenter::chartItems() const
             {
                 return m_chartItems;
             }
             ChartTitle *ChartPresenter::titleElement()
             {
                 return m_title;
             }
             QRectF ChartPresenter::textBoundingRect(const QFont &font, const QString &text, qreal angle)
             {
                 static QGraphicsTextItem dummyTextItem;
                 static bool initMargin = true;
                 if (initMargin) {
                     dummyTextItem.document()->setDocumentMargin(textMargin());
                     initMargin = false;
                 }
                 dummyTextItem.setFont(font);
                 dummyTextItem.setHtml(text);
                 QRectF boundingRect = dummyTextItem.boundingRect();
                 // Take rotation into account
                 if (angle) {
                     QTransform transform;
                     transform.rotate(angle);
                     boundingRect = transform.mapRect(boundingRect);
                 }
                 return boundingRect;
             }
             // boundingRect parameter returns the rotated bounding rect of the text
             QString ChartPresenter::truncatedText(const QFont &font, const QString &text, qreal angle,
                                                   qreal maxWidth, qreal maxHeight, QRectF &boundingRect)
             {
                 QString truncatedString(text);
                 boundingRect = textBoundingRect(font, truncatedString, angle);
                 if (boundingRect.width() > maxWidth || boundingRect.height() > maxHeight) {
                     // It can be assumed that almost any amount of string manipulation is faster
                     // than calculating one bounding rectangle, so first prepare a list of truncated strings
                     // to try.
                     static QRegExp truncateMatcher(QStringLiteral("&#?[0-9a-zA-Z]*;$"));
                     QVector<QString> testStrings(text.length());
                     int count(0);
                     static QLatin1Char closeTag('>');
                     static QLatin1Char openTag('<');
                     static QLatin1Char semiColon(';');
                     static QLatin1String ellipsis("...");
                     while (truncatedString.length() > 1) {
                         int chopIndex(-1);
                         int chopCount(1);
                         QChar lastChar(truncatedString.at(truncatedString.length() - 1));
                         if (lastChar == closeTag)
                             chopIndex = truncatedString.lastIndexOf(openTag);
                         else if (lastChar == semiColon)
                             chopIndex = truncateMatcher.indexIn(truncatedString, 0);
                         if (chopIndex != -1)
                             chopCount = truncatedString.length() - chopIndex;
                         truncatedString.chop(chopCount);
                         testStrings[count] = truncatedString + ellipsis;
                         count++;
                     }
                     // Binary search for best fit
                     int minIndex(0);
                     int maxIndex(count - 1);
                     int bestIndex(count);
                     QRectF checkRect;
                     while (maxIndex >= minIndex) {
                         int mid = (maxIndex + minIndex) / 2;
                         checkRect = textBoundingRect(font, testStrings.at(mid), angle);
                         if (checkRect.width() > maxWidth || checkRect.height() > maxHeight) {
                             // Checked index too large, all under this are also too large
                             minIndex = mid + 1;
                         } else {
                             // Checked index fits, all over this also fit
                             maxIndex = mid - 1;
                             bestIndex = mid;
                             boundingRect = checkRect;
                         }
                     }
                     // Default to "..." if nothing fits
                     if (bestIndex == count) {
                         boundingRect = textBoundingRect(font, ellipsis, angle);
                         truncatedString = ellipsis;
                     } else {
                         truncatedString = testStrings.at(bestIndex);
                     }
                 }
                 return truncatedString;
             }
             QString ChartPresenter::numberToString(double value, char f, int prec)
             {
                 if (m_localizeNumbers)
                     return m_locale.toString(value, f, prec);
                 else
                     return QString::number(value, f, prec);
             }
             QString ChartPresenter::numberToString(int value)
             {
                 if (m_localizeNumbers)
                     return m_locale.toString(value);
                 else
                     return QString::number(value);
             }
+            void ChartPresenter::ensureGLWidget()
+            {
+            #ifndef QT_NO_OPENGL
+                // GLWidget pointer is wrapped in QPointer as its parent is not in our control, and therefore
+                // can potentially get deleted unexpectedly.
+                if (m_glWidget.isNull() && m_glUseWidget && m_chart->scene()) {
+                    QObject *parent = m_chart->scene()->parent();
+                    while (parent) {
+                        QWidget *parentWidget = qobject_cast<QWidget *>(parent);
+                        if (parentWidget) {
+                            m_glWidget = new GLWidget(m_chart->d_ptr->m_dataset->glXYSeriesDataManager(),
+                                                      parentWidget);
+                            m_glWidget->setGeometry(m_rect.toRect());
+                            m_glWidget->show();
+                            break;
+                        }
+                        parent = parent->parent();
+                    }
+                }
+            #endif
+            }
             #include "moc_chartpresenter_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/chartpresenter_p.h +9 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 CHARTPRESENTER_H
             #define CHARTPRESENTER_H
             #include <QtCharts/QChartGlobal>
             #include <QtCharts/QChart> //because of QChart::ChartThemeId
+            #include <private/glwidget_p.h>
             #include <QtCore/QRectF>
             #include <QtCore/QMargins>
             #include <QtCore/QLocale>
+            #include <QtCore/QPointer>
             QT_CHARTS_BEGIN_NAMESPACE
             class ChartItem;
             class AxisItem;
             class QAbstractSeries;
             class ChartDataSet;
             class AbstractDomain;
             class ChartAxisElement;
             class ChartAnimator;
             class ChartBackground;
             class ChartTitle;
             class ChartAnimation;
             class AbstractChartLayout;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     PlotAreaZValue,
                     ShadesZValue,
                     GridZValue,
                     AxisZValue,
                     SeriesZValue,
                     LineChartZValue = SeriesZValue,
                     SplineChartZValue = SeriesZValue,
                     BarSeriesZValue = SeriesZValue,
                     ScatterSeriesZValue = SeriesZValue,
                     PieSeriesZValue = SeriesZValue,
                     BoxPlotSeriesZValue = SeriesZValue,
                     LegendZValue,
                     TopMostZValue
                 };
                 enum State {
                     ShowState,
                     ScrollUpState,
                     ScrollDownState,
                     ScrollLeftState,
                     ScrollRightState,
                     ZoomInState,
                     ZoomOutState
                 };
                 ChartPresenter(QChart *chart, QChart::ChartType type);
                 virtual ~ChartPresenter();
                 void setGeometry(QRectF rect);
                 QRectF geometry() const;
                 QGraphicsItem *rootItem(){ return m_chart; }
                 ChartBackground *backgroundElement();
                 QAbstractGraphicsShapeItem *plotAreaElement();
                 ChartTitle *titleElement();
                 QList<ChartAxisElement *> axisItems() const;
                 QList<ChartItem *> chartItems() const;
                 QLegend *legend();
                 void setBackgroundBrush(const QBrush &brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen &pen);
                 QPen backgroundPen() const;
                 void setBackgroundRoundness(qreal diameter);
                 qreal backgroundRoundness() const;
                 void setPlotAreaBackgroundBrush(const QBrush &brush);
                 QBrush plotAreaBackgroundBrush() const;
                 void setPlotAreaBackgroundPen(const QPen &pen);
                 QPen plotAreaBackgroundPen() const;
                 void setTitle(const QString &title);
                 QString title() const;
                 void setTitleFont(const QFont &font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundVisible(bool visible);
                 bool isBackgroundVisible() const;
                 void setPlotAreaBackgroundVisible(bool visible);
                 bool isPlotAreaBackgroundVisible() const;
                 void setBackgroundDropShadowEnabled(bool enabled);
                 bool isBackgroundDropShadowEnabled() const;
                 void setLocalizeNumbers(bool localize);
                 inline bool localizeNumbers() const { return m_localizeNumbers; }
                 void setLocale(const QLocale &locale);
                 inline const QLocale &locale() const { return m_locale; }
                 void setVisible(bool visible);
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void setAnimationDuration(int msecs);
                 int animationDuration() const { return m_animationDuration; }
                 void setAnimationEasingCurve(const QEasingCurve &curve);
                 QEasingCurve animationEasingCurve() const { return m_animationCurve; }
                 void startAnimation(ChartAnimation *animation);
                 void setState(State state,QPointF point);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
                 AbstractChartLayout *layout();
                 QChart::ChartType chartType() const { return m_chart->chartType(); }
                 QChart *chart() { return m_chart; }
                 static QRectF textBoundingRect(const QFont &font, const QString &text, qreal angle = 0.0);
                 static QString truncatedText(const QFont &font, const QString &text, qreal angle,
                                              qreal maxWidth, qreal maxHeight, QRectF &boundingRect);
                 inline static qreal textMargin() { return qreal(0.5); }
                 QString numberToString(double value, char f = 'g', int prec = 6);
                 QString numberToString(int value);
+                void ensureGLWidget();
+                void glSetUseWidget(bool enable) { m_glUseWidget = enable; }
             private:
                 void createBackgroundItem();
                 void createPlotAreaBackgroundItem();
                 void createTitleItem();
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series);
                 void handleSeriesRemoved(QAbstractSeries *series);
                 void handleAxisAdded(QAbstractAxis *axis);
                 void handleAxisRemoved(QAbstractAxis *axis);
             Q_SIGNALS:
                 void plotAreaChanged(const QRectF &plotArea);
             private:
                 QChart *m_chart;
                 QList<ChartItem *> m_chartItems;
                 QList<ChartAxisElement *> m_axisItems;
                 QList<QAbstractSeries *> m_series;
                 QList<QAbstractAxis *> m_axes;
                 QChart::AnimationOptions m_options;
                 int m_animationDuration;
                 QEasingCurve m_animationCurve;
                 State m_state;
                 QPointF m_statePoint;
                 AbstractChartLayout *m_layout;
                 ChartBackground *m_background;
                 QAbstractGraphicsShapeItem *m_plotAreaBackground;
                 ChartTitle *m_title;
                 QRectF m_rect;
                 bool m_localizeNumbers;
                 QLocale m_locale;
+            #ifndef QT_NO_OPENGL
+                QPointer<GLWidget> m_glWidget;
+            #endif
+                bool m_glUseWidget;
             };
             QT_CHARTS_END_NAMESPACE
             #endif /* CHARTPRESENTER_H */

src/charts/charts.pro +6 0

             ############################# BUILD CONFIG ######################################
             TARGET = QtCharts
             message($$QT_CONFIG)
             QT = core gui widgets
             DEFINES += QT_CHARTS_LIBRARY
             # Fix exports in static builds for applications linking charts module
             static: MODULE_DEFINES += QT_CHARTS_STATICLIB
             MODULE_INCNAME = QtCharts
             QMAKE_DOCS = $$PWD/doc/qtcharts.qdocconf
             load(qt_module)
             QMAKE_TARGET_PRODUCT = "Qt Charts (Qt $$QT_VERSION)"
             QMAKE_TARGET_DESCRIPTION = "Charts component for Qt."
             ############################# SOURCES ##########################################
             SOURCES += \
                 $$PWD/chartdataset.cpp \
                 $$PWD/chartpresenter.cpp \
                 $$PWD/chartthememanager.cpp \
                 $$PWD/qchart.cpp \
                 $$PWD/qchartview.cpp \
                 $$PWD/qabstractseries.cpp \
                 $$PWD/chartbackground.cpp \
                 $$PWD/chartelement.cpp \
                 $$PWD/chartitem.cpp \
                 $$PWD/scroller.cpp \
                 $$PWD/charttitle.cpp \
                 $$PWD/qpolarchart.cpp
+            contains(QT_CONFIG, opengl): SOURCES += $$PWD/glwidget.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartdataset_p.h \
                 $$PWD/chartitem_p.h \
                 $$PWD/chartpresenter_p.h \
                 $$PWD/chartthememanager_p.h \
                 $$PWD/chartbackground_p.h \
                 $$PWD/chartelement_p.h \
                 $$PWD/chartconfig_p.h \
                 $$PWD/qchart_p.h \
                 $$PWD/qchartview_p.h \
                 $$PWD/scroller_p.h \
                 $$PWD/qabstractseries_p.h \
                 $$PWD/charttitle_p.h \
                 $$PWD/charthelpers_p.h
+            contains(QT_CONFIG, opengl): PRIVATE_HEADERS += $$PWD/glwidget_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qchart.h \
                 $$PWD/qchartglobal.h \
                 $$PWD/qabstractseries.h \
                 $$PWD/qchartview.h \
                 $$PWD/chartsnamespace.h \
                 $$PWD/qpolarchart.h
             include($$PWD/common.pri)
             include($$PWD/animations/animations.pri)
             include($$PWD/areachart/areachart.pri)
             include($$PWD/axis/axis.pri)
             include($$PWD/domain/domain.pri)
             include($$PWD/barchart/barchart.pri)
             include($$PWD/legend/legend.pri)
             include($$PWD/linechart/linechart.pri)
             include($$PWD/piechart/piechart.pri)
             include($$PWD/scatterchart/scatter.pri)
             include($$PWD/splinechart/splinechart.pri)
             include($$PWD/themes/themes.pri)
             include($$PWD/xychart/xychart.pri)
             include($$PWD/layout/layout.pri)
             include($$PWD/boxplotchart/boxplotchart.pri)
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             OTHER_FILES += doc/qtcharts.qdocconf \
                            doc/src/* \
                            doc/images/*
             #Define for unit tests
             CONFIG(debug, debug|release) {
                 DEFINES += BUILD_PRIVATE_UNIT_TESTS
             }
             msvc {
                 # Suppress "conversion from 'size_t' to 'int', possible loss of data" warnings in 64bit
                 # builds resulting from usage of str::sort
                 QMAKE_CXXFLAGS_WARN_ON += -wd4267
             }
             win32:!winrt:!wince {
                 # ChartThemeSystem uses Windows native API
                 LIBS += -luser32
             }

src/charts/domain/abstractdomain_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 ABSTRACTDOMAIN_H
             #define ABSTRACTDOMAIN_H
             #include <QtCharts/QChartGlobal>
             #include <QtCore/QRectF>
             #include <QtCore/QSizeF>
             #include <QtCore/QDebug>
             QT_CHARTS_BEGIN_NAMESPACE
             class QAbstractAxis;
             class QT_CHARTS_AUTOTEST_EXPORT AbstractDomain: public QObject
             {
                 Q_OBJECT
             public:
                 enum DomainType { UndefinedDomain,
                                   XYDomain,
                                   XLogYDomain,
                                   LogXYDomain,
                                   LogXLogYDomain,
                                   XYPolarDomain,
                                   XLogYPolarDomain,
                                   LogXYPolarDomain,
                                   LogXLogYPolarDomain };
             public:
                 explicit AbstractDomain(QObject *object = 0);
                 virtual ~AbstractDomain();
                 virtual void setSize(const QSizeF &size);
                 QSizeF size() const;
                 virtual DomainType type() = 0;
                 virtual void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY) = 0;
                 void setRangeX(qreal min, qreal max);
                 void setRangeY(qreal min, qreal max);
                 void setMinX(qreal min);
                 void setMaxX(qreal max);
                 void setMinY(qreal min);
                 void setMaxY(qreal max);
                 qreal minX() const { return m_minX; }
                 qreal maxX() const { return m_maxX; }
                 qreal minY() const { return m_minY; }
                 qreal maxY() const { return m_maxY; }
                 qreal spanX() const;
                 qreal spanY() const;
                 bool isEmpty() const;
                 void blockRangeSignals(bool block);
                 bool rangeSignalsBlocked() const { return m_signalsBlocked; }
                 void zoomReset();
                 void storeZoomReset();
                 bool isZoomed() { return m_zoomed; }
                 friend bool QT_CHARTS_AUTOTEST_EXPORT operator== (const AbstractDomain &domain1, const AbstractDomain &domain2);
                 friend bool QT_CHARTS_AUTOTEST_EXPORT operator!= (const AbstractDomain &domain1, const AbstractDomain &domain2);
                 friend QDebug QT_CHARTS_AUTOTEST_EXPORT operator<<(QDebug dbg, const AbstractDomain &domain);
                 virtual void zoomIn(const QRectF &rect) = 0;
                 virtual void zoomOut(const QRectF &rect) = 0;
                 virtual void move(qreal dx, qreal dy) = 0;
                 virtual QPointF calculateGeometryPoint(const QPointF &point, bool &ok) const = 0;
                 virtual QPointF calculateDomainPoint(const QPointF &point) const = 0;
-                virtual QVector<QPointF> calculateGeometryPoints(const QList<QPointF> &vector) const = 0;
+                virtual QVector<QPointF> calculateGeometryPoints(const QVector<QPointF> &vector) const = 0;
                 virtual bool attachAxis(QAbstractAxis *axis);
                 virtual bool detachAxis(QAbstractAxis *axis);
                 static void looseNiceNumbers(qreal &min, qreal &max, int &ticksCount);
                 static qreal niceNumber(qreal x, bool ceiling);
             Q_SIGNALS:
                 void updated();
                 void rangeHorizontalChanged(qreal min, qreal max);
                 void rangeVerticalChanged(qreal min, qreal max);
             public Q_SLOTS:
                 void handleVerticalAxisRangeChanged(qreal min,qreal max);
                 void handleHorizontalAxisRangeChanged(qreal min,qreal max);
             protected:
                 void adjustLogDomainRanges(qreal &min, qreal &max);
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 QSizeF m_size;
                 bool m_signalsBlocked;
                 bool m_zoomed;
                 qreal m_zoomResetMinX;
                 qreal m_zoomResetMaxX;
                 qreal m_zoomResetMinY;
                 qreal m_zoomResetMaxY;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // ABSTRACTDOMAIN_H

src/charts/domain/logxlogydomain.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/logxlogydomain_p.h>
             #include <private/qabstractaxis_p.h>
             #include <QtCharts/QLogValueAxis>
             #include <QtCore/QtMath>
             #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
             LogXLogYDomain::LogXLogYDomain(QObject *parent)
                 : AbstractDomain(parent),
                   m_logLeftX(0),
                   m_logRightX(1),
                   m_logBaseX(10),
                   m_logLeftY(0),
                   m_logRightY(1),
                   m_logBaseY(10)
             {
             }
             LogXLogYDomain::~LogXLogYDomain()
             {
             }
             void LogXLogYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 bool axisXChanged = false;
                 bool axisYChanged = false;
                 adjustLogDomainRanges(minX, maxX);
                 adjustLogDomainRanges(minY, maxY);
                 if (!qFuzzyIsNull(m_minX - minX) || !qFuzzyIsNull(m_maxX - maxX)) {
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
                     qreal logMinX = std::log10(m_minX) / std::log10(m_logBaseX);
                     qreal logMaxX = std::log10(m_maxX) / std::log10(m_logBaseX);
                     m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
                     m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
                     if(!m_signalsBlocked)
                         emit rangeHorizontalChanged(m_minX, m_maxX);
                 }
                 if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
                     qreal logMinY = std::log10(m_minY) / std::log10(m_logBaseY);
                     qreal logMaxY = std::log10(m_maxY) / std::log10(m_logBaseY);
                     m_logLeftY = logMinY < logMaxY ? logMinY : logMaxY;
                     m_logRightY = logMinY > logMaxY ? logMinY : logMaxY;
                     if (!m_signalsBlocked)
                         emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                 if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void LogXLogYDomain::zoomIn(const QRectF &rect)
             {
                 storeZoomReset();
                 qreal logLeftX = rect.left() * (m_logRightX - m_logLeftX) / m_size.width() + m_logLeftX;
                 qreal logRightX = rect.right() * (m_logRightX - m_logLeftX) / m_size.width() + m_logLeftX;
                 qreal leftX = qPow(m_logBaseX, logLeftX);
                 qreal rightX = qPow(m_logBaseX, logRightX);
                 qreal minX = leftX < rightX ? leftX : rightX;
                 qreal maxX = leftX > rightX ? leftX : rightX;
                 qreal logLeftY = m_logRightY - rect.bottom() * (m_logRightY - m_logLeftY) / m_size.height();
                 qreal logRightY = m_logRightY - rect.top() * (m_logRightY - m_logLeftY) / m_size.height();
                 qreal leftY = qPow(m_logBaseY, logLeftY);
                 qreal rightY = qPow(m_logBaseY, logRightY);
                 qreal minY = leftY < rightY ? leftY : rightY;
                 qreal maxY = leftY > rightY ? leftY : rightY;
                 setRange(minX, maxX, minY, maxY);
             }
             void LogXLogYDomain::zoomOut(const QRectF &rect)
             {
                 storeZoomReset();
                 const qreal factorX = m_size.width() / rect.width();
                 const qreal factorY = m_size.height() / rect.height();
                 qreal logLeftX = m_logLeftX + (m_logRightX - m_logLeftX) / 2 * (1 - factorX);
                 qreal logRIghtX = m_logLeftX + (m_logRightX - m_logLeftX) / 2 * (1 + factorX);
                 qreal leftX = qPow(m_logBaseX, logLeftX);
                 qreal rightX = qPow(m_logBaseX, logRIghtX);
                 qreal minX = leftX < rightX ? leftX : rightX;
                 qreal maxX = leftX > rightX ? leftX : rightX;
                 qreal newLogMinY = m_logLeftY + (m_logRightY - m_logLeftY) / 2 * (1 - factorY);
                 qreal newLogMaxY = m_logLeftY + (m_logRightY - m_logLeftY) / 2 * (1 + factorY);
                 qreal leftY = qPow(m_logBaseY, newLogMinY);
                 qreal rightY = qPow(m_logBaseY, newLogMaxY);
                 qreal minY = leftY < rightY ? leftY : rightY;
                 qreal maxY = leftY > rightY ? leftY : rightY;
                 setRange(minX, maxX, minY, maxY);
             }
             void LogXLogYDomain::move(qreal dx, qreal dy)
             {
                 qreal stepX = dx * qAbs(m_logRightX - m_logLeftX) / m_size.width();
                 qreal leftX = qPow(m_logBaseX, m_logLeftX + stepX);
                 qreal rightX = qPow(m_logBaseX, m_logRightX + stepX);
                 qreal minX = leftX < rightX ? leftX : rightX;
                 qreal maxX = leftX > rightX ? leftX : rightX;
                 qreal stepY = dy * (m_logRightY - m_logLeftY) / m_size.height();
                 qreal leftY = qPow(m_logBaseY, m_logLeftY + stepY);
                 qreal rightY = qPow(m_logBaseY, m_logRightY + stepY);
                 qreal minY = leftY < rightY ? leftY : rightY;
                 qreal maxY = leftY > rightY ? leftY : rightY;
                 setRange(minX, maxX, minY, maxY);
             }
             QPointF LogXLogYDomain::calculateGeometryPoint(const QPointF &point, bool &ok) const
             {
                 const qreal deltaX = m_size.width() / qAbs(m_logRightX - m_logLeftX);
                 const qreal deltaY = m_size.height() / qAbs(m_logRightY - m_logLeftY);
                 qreal x(0);
                 qreal y(0);
                 if (point.x() > 0 && point.y() > 0) {
                     x = (std::log10(point.x()) / std::log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
                     y = (std::log10(point.y()) / std::log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
                     ok = true;
                 } else {
                     qWarning() << "Logarithms of zero and negative values are undefined.";
                     ok = false;
                     if (point.x() > 0)
                         x = (std::log10(point.x()) / std::log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
                     else
                         x = 0;
                     if (point.y() > 0) {
                         y = (std::log10(point.y()) / std::log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY
                                 + m_size.height();
                     } else {
                         y = m_size.height();
                     }
                 }
                 return QPointF(x, y);
             }
-            QVector<QPointF> LogXLogYDomain::calculateGeometryPoints(const QList<QPointF> &vector) const
+            QVector<QPointF> LogXLogYDomain::calculateGeometryPoints(const QVector<QPointF> &vector) const
             {
                 const qreal deltaX = m_size.width() / qAbs(m_logRightX - m_logLeftX);
                 const qreal deltaY = m_size.height() / qAbs(m_logRightY - m_logLeftY);
                 QVector<QPointF> result;
                 result.resize(vector.count());
                 for (int i = 0; i < vector.count(); ++i) {
                     if (vector[i].x() > 0 && vector[i].y() > 0) {
                         qreal x = (std::log10(vector[i].x()) / std::log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
                         qreal y = (std::log10(vector[i].y()) / std::log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
                         result[i].setX(x);
                         result[i].setY(y);
                     } else {
                         qWarning() << "Logarithms of zero and negative values are undefined.";
                         return QVector<QPointF>();
                     }
                 }
                 return result;
             }
             QPointF LogXLogYDomain::calculateDomainPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width() / qAbs(m_logRightX - m_logLeftX);
                 const qreal deltaY = m_size.height() / qAbs(m_logRightY - m_logLeftY);
                 qreal x = qPow(m_logBaseX, m_logLeftX + point.x() / deltaX);
                 qreal y = qPow(m_logBaseY, m_logLeftY + (m_size.height() - point.y()) / deltaY);
                 return QPointF(x, y);
             }
             bool LogXLogYDomain::attachAxis(QAbstractAxis *axis)
             {
                 AbstractDomain::attachAxis(axis);
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
                 if (logAxis && logAxis->orientation() == Qt::Vertical) {
                     QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
                     handleVerticalAxisBaseChanged(logAxis->base());
                 }
                 if (logAxis && logAxis->orientation() == Qt::Horizontal) {
                     QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
                     handleHorizontalAxisBaseChanged(logAxis->base());
                 }
                 return true;
             }
             bool LogXLogYDomain::detachAxis(QAbstractAxis *axis)
             {
                 AbstractDomain::detachAxis(axis);
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
                 if (logAxis && logAxis->orientation() == Qt::Vertical)
                     QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
                 if (logAxis && logAxis->orientation() == Qt::Horizontal)
                     QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
                 return true;
             }
             void LogXLogYDomain::handleVerticalAxisBaseChanged(qreal baseY)
             {
                 m_logBaseY = baseY;
                 qreal logMinY = std::log10(m_minY) / std::log10(m_logBaseY);
                 qreal logMaxY = std::log10(m_maxY) / std::log10(m_logBaseY);
                 m_logLeftY = logMinY < logMaxY ? logMinY : logMaxY;
                 m_logRightY = logMinY > logMaxY ? logMinY : logMaxY;
                 emit updated();
             }
             void LogXLogYDomain::handleHorizontalAxisBaseChanged(qreal baseX)
             {
                 m_logBaseX = baseX;
                 qreal logMinX = std::log10(m_minX) / std::log10(m_logBaseX);
                 qreal logMaxX = std::log10(m_maxX) / std::log10(m_logBaseX);
                 m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
                 m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
                 emit updated();
             }
             // operators
             bool QT_CHARTS_AUTOTEST_EXPORT operator== (const LogXLogYDomain &domain1, const LogXLogYDomain &domain2)
             {
                 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX)
                         && qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY)
                         && qFuzzyIsNull(domain1.m_minX - domain2.m_minX)
                         && qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
             }
             bool QT_CHARTS_AUTOTEST_EXPORT operator!= (const LogXLogYDomain &domain1, const LogXLogYDomain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug QT_CHARTS_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXLogYDomain &domain)
             {
             #ifdef QT_NO_TEXTSTREAM
                 Q_UNUSED(domain)
             #else
                 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
             #endif
                 return dbg.maybeSpace();
             }
             #include "moc_logxlogydomain_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/domain/logxlogydomain_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 LOGXLOGYDOMAIN_H
             #define LOGXLOGYDOMAIN_H
             #include <private/abstractdomain_p.h>
             #include <QtCore/QRectF>
             #include <QtCore/QSizeF>
             QT_CHARTS_BEGIN_NAMESPACE
             class QT_CHARTS_AUTOTEST_EXPORT LogXLogYDomain: public AbstractDomain
             {
                 Q_OBJECT
             public:
                 explicit LogXLogYDomain(QObject *object = 0);
                 virtual ~LogXLogYDomain();
                 DomainType type(){ return AbstractDomain::LogXLogYDomain;}
                 void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 friend bool QT_CHARTS_AUTOTEST_EXPORT operator== (const LogXLogYDomain &domain1, const LogXLogYDomain &domain2);
                 friend bool QT_CHARTS_AUTOTEST_EXPORT operator!= (const LogXLogYDomain &domain1, const LogXLogYDomain &domain2);
                 friend QDebug QT_CHARTS_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXLogYDomain &domain);
                 void zoomIn(const QRectF &rect);
                 void zoomOut(const QRectF &rect);
                 void move(qreal dx, qreal dy);
                 QPointF calculateGeometryPoint(const QPointF &point, bool &ok) const;
                 QPointF calculateDomainPoint(const QPointF &point) const;
-                QVector<QPointF> calculateGeometryPoints(const QList<QPointF> &vector) const;
+                QVector<QPointF> calculateGeometryPoints(const QVector<QPointF> &vector) const;
                 bool attachAxis(QAbstractAxis *axis);
                 bool detachAxis(QAbstractAxis *axis);
             public Q_SLOTS:
                 void handleVerticalAxisBaseChanged(qreal baseY);
                 void handleHorizontalAxisBaseChanged(qreal baseX);
             private:
                 qreal m_logLeftX;
                 qreal m_logRightX;
                 qreal m_logBaseX;
                 qreal m_logLeftY;
                 qreal m_logRightY;
                 qreal m_logBaseY;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // LOGXLOGYDOMAIN_H

src/charts/domain/logxydomain.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/logxydomain_p.h>
             #include <private/qabstractaxis_p.h>
             #include <QtCharts/QLogValueAxis>
             #include <QtCore/QtMath>
             #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
             LogXYDomain::LogXYDomain(QObject *parent)
                 : AbstractDomain(parent),
                   m_logLeftX(0),
                   m_logRightX(1),
                   m_logBaseX(10)
             {
             }
             LogXYDomain::~LogXYDomain()
             {
             }
             void LogXYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 bool axisXChanged = false;
                 bool axisYChanged = false;
                 adjustLogDomainRanges(minX, maxX);
                 if (!qFuzzyCompare(m_minX, minX) || !qFuzzyCompare(m_maxX, maxX)) {
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
                     qreal logMinX = std::log10(m_minX) / std::log10(m_logBaseX);
                     qreal logMaxX = std::log10(m_maxX) / std::log10(m_logBaseX);
                     m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
                     m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
                     if(!m_signalsBlocked)
                         emit rangeHorizontalChanged(m_minX, m_maxX);
                 }
                 if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
                     if (!m_signalsBlocked)
                         emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                 if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void LogXYDomain::zoomIn(const QRectF &rect)
             {
                 storeZoomReset();
                 qreal logLeftX = rect.left() * (m_logRightX - m_logLeftX) / m_size.width() + m_logLeftX;
                 qreal logRightX = rect.right() * (m_logRightX - m_logLeftX) / m_size.width() + m_logLeftX;
                 qreal leftX = qPow(m_logBaseX, logLeftX);
                 qreal rightX = qPow(m_logBaseX, logRightX);
                 qreal minX = leftX < rightX ? leftX : rightX;
                 qreal maxX = leftX > rightX ? leftX : rightX;
                 qreal dy = spanY() / m_size.height();
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 minY = maxY - dy * rect.bottom();
                 maxY = maxY - dy * rect.top();
                 setRange(minX, maxX, minY, maxY);
             }
             void LogXYDomain::zoomOut(const QRectF &rect)
             {
                 storeZoomReset();
                 const qreal factorX = m_size.width() / rect.width();
                 qreal logLeftX = m_logLeftX + (m_logRightX - m_logLeftX) / 2 * (1 - factorX);
                 qreal logRIghtX = m_logLeftX + (m_logRightX - m_logLeftX) / 2 * (1 + factorX);
                 qreal leftX = qPow(m_logBaseX, logLeftX);
                 qreal rightX = qPow(m_logBaseX, logRIghtX);
                 qreal minX = leftX < rightX ? leftX : rightX;
                 qreal maxX = leftX > rightX ? leftX : rightX;
                 qreal dy = spanY() / rect.height();
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 maxY = minY + dy * rect.bottom();
                 minY = maxY - dy * m_size.height();
                 setRange(minX, maxX, minY, maxY);
             }
             void LogXYDomain::move(qreal dx, qreal dy)
             {
                 qreal stepX = dx * (m_logRightX - m_logLeftX) / m_size.width();
                 qreal leftX = qPow(m_logBaseX, m_logLeftX + stepX);
                 qreal rightX = qPow(m_logBaseX, m_logRightX + stepX);
                 qreal minX = leftX < rightX ? leftX : rightX;
                 qreal maxX = leftX > rightX ? leftX : rightX;
                 qreal y = spanY() / m_size.height();
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 if (dy != 0) {
                     minY = minY + y * dy;
                     maxY = maxY + y * dy;
                 }
                 setRange(minX, maxX, minY, maxY);
             }
             QPointF LogXYDomain::calculateGeometryPoint(const QPointF &point, bool &ok) const
             {
                 const qreal deltaX = m_size.width() / (m_logRightX - m_logLeftX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 qreal x(0);
                 qreal y = (point.y() - m_minY) * -deltaY + m_size.height();
                 if (point.x() > 0) {
                     x = (std::log10(point.x()) / std::log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
                     ok = true;
                 } else {
                     x = 0;
                     qWarning() << "Logarithms of zero and negative values are undefined.";
                     ok = false;
                 }
                 return QPointF(x, y);
             }
-            QVector<QPointF> LogXYDomain::calculateGeometryPoints(const QList<QPointF> &vector) const
+            QVector<QPointF> LogXYDomain::calculateGeometryPoints(const QVector<QPointF> &vector) const
             {
                 const qreal deltaX = m_size.width() / (m_logRightX - m_logLeftX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 QVector<QPointF> result;
                 result.resize(vector.count());
                 for (int i = 0; i < vector.count(); ++i) {
                     if (vector[i].x() > 0) {
                         qreal x = (std::log10(vector[i].x()) / std::log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
                         qreal y = (vector[i].y() - m_minY) * -deltaY + m_size.height();
                         result[i].setX(x);
                         result[i].setY(y);
                     } else {
                         qWarning() << "Logarithms of zero and negative values are undefined.";
                         return QVector<QPointF>();
                     }
                 }
                 return result;
             }
             QPointF LogXYDomain::calculateDomainPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width() / (m_logRightX - m_logLeftX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 qreal x = qPow(m_logBaseX, m_logLeftX + point.x() / deltaX);
                 qreal y = (point.y() - m_size.height()) / (-deltaY) + m_minY;
                 return QPointF(x, y);
             }
             bool LogXYDomain::attachAxis(QAbstractAxis *axis)
             {
                 AbstractDomain::attachAxis(axis);
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
                 if (logAxis && logAxis->orientation() == Qt::Horizontal) {
                     QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
                     handleHorizontalAxisBaseChanged(logAxis->base());
                 }
                 return true;
             }
             bool LogXYDomain::detachAxis(QAbstractAxis *axis)
             {
                 AbstractDomain::detachAxis(axis);
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
                 if (logAxis && logAxis->orientation() == Qt::Horizontal)
                     QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
                 return true;
             }
             void LogXYDomain::handleHorizontalAxisBaseChanged(qreal baseX)
             {
                 m_logBaseX = baseX;
                 qreal logMinX = std::log10(m_minX) / std::log10(m_logBaseX);
                 qreal logMaxX = std::log10(m_maxX) / std::log10(m_logBaseX);
                 m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
                 m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
                 emit updated();
             }
             // operators
             bool QT_CHARTS_AUTOTEST_EXPORT operator== (const LogXYDomain &domain1, const LogXYDomain &domain2)
             {
                 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX)
                         && qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY)
                         && qFuzzyIsNull(domain1.m_minX - domain2.m_minX)
                         && qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
             }
             bool QT_CHARTS_AUTOTEST_EXPORT operator!= (const LogXYDomain &domain1, const LogXYDomain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug QT_CHARTS_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXYDomain &domain)
             {
             #ifdef QT_NO_TEXTSTREAM
                 Q_UNUSED(domain)
             #else
                 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
             #endif
                 return dbg.maybeSpace();
             }
             #include "moc_logxydomain_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/domain/logxydomain_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 LOGXYDOMAIN_H
             #define LOGXYDOMAIN_H
             #include <private/abstractdomain_p.h>
             #include <QtCore/QRectF>
             #include <QtCore/QSizeF>
             QT_CHARTS_BEGIN_NAMESPACE
             class QT_CHARTS_AUTOTEST_EXPORT LogXYDomain: public AbstractDomain
             {
                 Q_OBJECT
             public:
                 explicit LogXYDomain(QObject *object = 0);
                 virtual ~LogXYDomain();
                 DomainType type(){ return AbstractDomain::LogXYDomain;}
                 void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 friend bool QT_CHARTS_AUTOTEST_EXPORT operator== (const LogXYDomain &domain1, const LogXYDomain &domain2);
                 friend bool QT_CHARTS_AUTOTEST_EXPORT operator!= (const LogXYDomain &domain1, const LogXYDomain &domain2);
                 friend QDebug QT_CHARTS_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXYDomain &domain);
                 void zoomIn(const QRectF &rect);
                 void zoomOut(const QRectF &rect);
                 void move(qreal dx, qreal dy);
                 QPointF calculateGeometryPoint(const QPointF &point, bool &ok) const;
                 QPointF calculateDomainPoint(const QPointF &point) const;
-                QVector<QPointF> calculateGeometryPoints(const QList<QPointF> &vector) const;
+                QVector<QPointF> calculateGeometryPoints(const QVector<QPointF> &vector) const;
                 bool attachAxis(QAbstractAxis *axis);
                 bool detachAxis(QAbstractAxis *axis);
             public Q_SLOTS:
                 void handleHorizontalAxisBaseChanged(qreal baseX);
             private:
                 qreal m_logLeftX;
                 qreal m_logRightX;
                 qreal m_logBaseX;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // LOGXYDOMAIN_H

src/charts/domain/polardomain.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/polardomain_p.h>
             #include <private/qabstractaxis_p.h>
             #include <QtCore/QtMath>
             QT_CHARTS_BEGIN_NAMESPACE
             PolarDomain::PolarDomain(QObject *parent)
                 : AbstractDomain(parent)
             {
             }
             PolarDomain::~PolarDomain()
             {
             }
             void PolarDomain::setSize(const QSizeF &size)
             {
                 Q_ASSERT(size.width() == size.height());
                 m_radius = size.height() / 2.0;
                 m_center = QPointF(m_radius, m_radius);
                 AbstractDomain::setSize(size);
             }
             QPointF PolarDomain::calculateGeometryPoint(const QPointF &point, bool &ok) const
             {
                 qreal r = 0.0;
                 qreal a = toAngularCoordinate(point.x(), ok);
                 if (ok)
                     r = toRadialCoordinate(point.y(), ok);
                 if (ok) {
                     return m_center + polarCoordinateToPoint(a, r);
                 } else {
                     qWarning() << "Logarithm of negative value is undefined. Empty layout returned.";
                     return QPointF();
                 }
             }
-            QVector<QPointF> PolarDomain::calculateGeometryPoints(const QList<QPointF> &vector) const
+            QVector<QPointF> PolarDomain::calculateGeometryPoints(const QVector<QPointF> &vector) const
             {
                 QVector<QPointF> result;
                 result.resize(vector.count());
                 bool ok;
                 qreal r = 0.0;
                 qreal a = 0.0;
                 for (int i = 0; i < vector.count(); ++i) {
                     a = toAngularCoordinate(vector[i].x(), ok);
                     if (ok)
                         r = toRadialCoordinate(vector[i].y(), ok);
                     if (ok) {
                         result[i] = m_center + polarCoordinateToPoint(a, r);
                     } else {
                         qWarning() << "Logarithm of negative value is undefined. Empty layout returned.";
                         return QVector<QPointF>();
                     }
                 }
                 return result;
             }
             QPointF PolarDomain::polarCoordinateToPoint(qreal angularCoordinate, qreal radialCoordinate) const
             {
                 qreal dx = qSin(angularCoordinate * (M_PI / 180)) * radialCoordinate;
                 qreal dy = qCos(angularCoordinate * (M_PI / 180)) * radialCoordinate;
                 return QPointF(dx, -dy);
             }
             #include "moc_polardomain_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/domain/polardomain_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 POLARDOMAIN_H
             #define POLARDOMAIN_H
             #include <private/abstractdomain_p.h>
             #include <QtCore/QRectF>
             #include <QtCore/QSizeF>
             QT_CHARTS_BEGIN_NAMESPACE
             class QT_CHARTS_AUTOTEST_EXPORT PolarDomain: public AbstractDomain
             {
                 Q_OBJECT
             public:
                 explicit PolarDomain(QObject *object = 0);
                 virtual ~PolarDomain();
                 void setSize(const QSizeF &size);
                 QPointF calculateGeometryPoint(const QPointF &point, bool &ok) const;
-                QVector<QPointF> calculateGeometryPoints(const QList<QPointF> &vector) const;
+                QVector<QPointF> calculateGeometryPoints(const QVector<QPointF> &vector) const;
                 virtual qreal toAngularCoordinate(qreal value, bool &ok) const = 0;
                 virtual qreal toRadialCoordinate(qreal value, bool &ok) const = 0;
             protected:
                 QPointF polarCoordinateToPoint(qreal angularCoordinate, qreal radialCoordinate) const;
                 QPointF m_center;
                 qreal m_radius;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // POLARDOMAIN_H

src/charts/domain/xlogydomain.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/xlogydomain_p.h>
             #include <private/qabstractaxis_p.h>
             #include <QtCharts/QLogValueAxis>
             #include <QtCore/QtMath>
             #include <cmath>
             QT_CHARTS_BEGIN_NAMESPACE
             XLogYDomain::XLogYDomain(QObject *parent)
                 : AbstractDomain(parent),
                   m_logLeftY(0),
                   m_logRightY(1),
                   m_logBaseY(10)
             {
             }
             XLogYDomain::~XLogYDomain()
             {
             }
             void XLogYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 bool axisXChanged = false;
                 bool axisYChanged = false;
                 adjustLogDomainRanges(minY, maxY);
                 if (!qFuzzyIsNull(m_minX - minX) || !qFuzzyIsNull(m_maxX - maxX)) {
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
                     if(!m_signalsBlocked)
                         emit rangeHorizontalChanged(m_minX, m_maxX);
                 }
                 if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
                     qreal logMinY = std::log10(m_minY) / std::log10(m_logBaseY);
                     qreal logMaxY = std::log10(m_maxY) / std::log10(m_logBaseY);
                     m_logLeftY = logMinY < logMaxY ? logMinY : logMaxY;
                     m_logRightY = logMinY > logMaxY ? logMinY : logMaxY;
                     if (!m_signalsBlocked)
                         emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                 if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void XLogYDomain::zoomIn(const QRectF &rect)
             {
                 storeZoomReset();
                 qreal dx = spanX() / m_size.width();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 maxX = minX + dx * rect.right();
                 minX = minX + dx * rect.left();
                 qreal logLeftY = m_logRightY - rect.bottom() * (m_logRightY - m_logLeftY) / m_size.height();
                 qreal logRightY = m_logRightY - rect.top() * (m_logRightY - m_logLeftY) / m_size.height();
                 qreal leftY = qPow(m_logBaseY, logLeftY);
                 qreal rightY = qPow(m_logBaseY, logRightY);
                 qreal minY = leftY < rightY ? leftY : rightY;
                 qreal maxY = leftY > rightY ? leftY : rightY;
                 setRange(minX, maxX, minY, maxY);
             }
             void XLogYDomain::zoomOut(const QRectF &rect)
             {
                 storeZoomReset();
                 qreal dx = spanX() / rect.width();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 minX = maxX - dx * rect.right();
                 maxX = minX + dx * m_size.width();
                 const qreal factorY = m_size.height() / rect.height();
                 qreal newLogMinY = m_logLeftY + (m_logRightY - m_logLeftY) / 2 * (1 - factorY);
                 qreal newLogMaxY = m_logLeftY + (m_logRightY - m_logLeftY) / 2 * (1 + factorY);
                 qreal leftY = qPow(m_logBaseY, newLogMinY);
                 qreal rightY = qPow(m_logBaseY, newLogMaxY);
                 qreal minY = leftY < rightY ? leftY : rightY;
                 qreal maxY = leftY > rightY ? leftY : rightY;
                 setRange(minX, maxX, minY, maxY);
             }
             void XLogYDomain::move(qreal dx, qreal dy)
             {
                 qreal x = spanX() / m_size.width();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 if (dx != 0) {
                     minX = minX + x * dx;
                     maxX = maxX + x * dx;
                 }
                 qreal stepY = dy * (m_logRightY - m_logLeftY) / m_size.height();
                 qreal leftY = qPow(m_logBaseY, m_logLeftY + stepY);
                 qreal rightY = qPow(m_logBaseY, m_logRightY + stepY);
                 qreal minY = leftY < rightY ? leftY : rightY;
                 qreal maxY = leftY > rightY ? leftY : rightY;
                 setRange(minX, maxX, minY, maxY);
             }
             QPointF XLogYDomain::calculateGeometryPoint(const QPointF &point, bool &ok) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / qAbs(m_logRightY - m_logLeftY);
                 qreal x = (point.x() - m_minX) * deltaX;
                 qreal y(0);
                 if (point.y() > 0) {
                     y = (std::log10(point.y()) / std::log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
                     ok = true;
                 } else {
                     y = m_size.height();
                     qWarning() << "Logarithms of zero and negative values are undefined.";
                     ok = false;
                 }
                 return QPointF(x, y);
             }
-            QVector<QPointF> XLogYDomain::calculateGeometryPoints(const QList<QPointF> &vector) const
+            QVector<QPointF> XLogYDomain::calculateGeometryPoints(const QVector<QPointF> &vector) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / qAbs(m_logRightY - m_logLeftY);
                 QVector<QPointF> result;
                 result.resize(vector.count());
                 for (int i = 0; i < vector.count(); ++i) {
                     if (vector[i].y() > 0) {
                         qreal x = (vector[i].x() - m_minX) * deltaX;
                         qreal y = (std::log10(vector[i].y()) / std::log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
                         result[i].setX(x);
                         result[i].setY(y);
                     } else {
                         qWarning() << "Logarithms of zero and negative values are undefined.";
                         return QVector<QPointF>();
                     }
                 }
                 return result;
             }
             QPointF XLogYDomain::calculateDomainPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / qAbs(m_logRightY - m_logLeftY);
                 qreal x = point.x() / deltaX + m_minX;
                 qreal y = qPow(m_logBaseY, m_logLeftY + (m_size.height() - point.y()) / deltaY);
                 return QPointF(x, y);
             }
             bool XLogYDomain::attachAxis(QAbstractAxis *axis)
             {
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
                 if (logAxis && logAxis->orientation() == Qt::Vertical) {
                     QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
                     handleVerticalAxisBaseChanged(logAxis->base());
                 }
                 return  AbstractDomain::attachAxis(axis);
             }
             bool XLogYDomain::detachAxis(QAbstractAxis *axis)
             {
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
                 if (logAxis && logAxis->orientation() == Qt::Vertical)
                     QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
                 return AbstractDomain::detachAxis(axis);
             }
             void XLogYDomain::handleVerticalAxisBaseChanged(qreal baseY)
             {
                 m_logBaseY = baseY;
                 qreal logMinY = std::log10(m_minY) / std::log10(m_logBaseY);
                 qreal logMaxY = std::log10(m_maxY) / std::log10(m_logBaseY);
                 m_logLeftY = logMinY < logMaxY ? logMinY : logMaxY;
                 m_logRightY = logMinY > logMaxY ? logMinY : logMaxY;
                 emit updated();
             }
             // operators
             bool QT_CHARTS_AUTOTEST_EXPORT operator== (const XLogYDomain &domain1, const XLogYDomain &domain2)
             {
                 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX)
                         && qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY)
                         && qFuzzyIsNull(domain1.m_minX - domain2.m_minX)
                         && qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
             }
             bool QT_CHARTS_AUTOTEST_EXPORT operator!= (const XLogYDomain &domain1, const XLogYDomain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug QT_CHARTS_AUTOTEST_EXPORT operator<<(QDebug dbg, const XLogYDomain &domain)
             {
             #ifdef QT_NO_TEXTSTREAM
                 Q_UNUSED(domain)
             #else
                 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
             #endif
                 return dbg.maybeSpace();
             }
             #include "moc_xlogydomain_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/domain/xlogydomain_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 XLOGYDOMAIN_H
             #define XLOGYDOMAIN_H
             #include <private/abstractdomain_p.h>
             #include <QtCore/QRectF>
             #include <QtCore/QSizeF>
             QT_CHARTS_BEGIN_NAMESPACE
             class QT_CHARTS_AUTOTEST_EXPORT XLogYDomain: public AbstractDomain
             {
                 Q_OBJECT
             public:
                 explicit XLogYDomain(QObject *object = 0);
                 virtual ~XLogYDomain();
                 DomainType type(){ return AbstractDomain::XLogYDomain;};
                 void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 friend bool QT_CHARTS_AUTOTEST_EXPORT operator== (const XLogYDomain &domain1, const XLogYDomain &domain2);
                 friend bool QT_CHARTS_AUTOTEST_EXPORT operator!= (const XLogYDomain &domain1, const XLogYDomain &domain2);
                 friend QDebug QT_CHARTS_AUTOTEST_EXPORT operator<<(QDebug dbg, const XLogYDomain &domain);
                 void zoomIn(const QRectF &rect);
                 void zoomOut(const QRectF &rect);
                 void move(qreal dx, qreal dy);
                 QPointF calculateGeometryPoint(const QPointF &point, bool &ok) const;
                 QPointF calculateDomainPoint(const QPointF &point) const;
-                QVector<QPointF> calculateGeometryPoints(const QList<QPointF> &vector) const;
+                QVector<QPointF> calculateGeometryPoints(const QVector<QPointF> &vector) const;
                 bool attachAxis(QAbstractAxis *axis);
                 bool detachAxis(QAbstractAxis *axis);
             public Q_SLOTS:
                 void handleVerticalAxisBaseChanged(qreal baseY);
             private:
                 qreal m_logLeftY;
                 qreal m_logRightY;
                 qreal m_logBaseY;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // XLOGYDOMAIN_H

src/charts/domain/xydomain.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/xydomain_p.h>
             #include <private/qabstractaxis_p.h>
             #include <QtCore/QtMath>
             QT_CHARTS_BEGIN_NAMESPACE
             XYDomain::XYDomain(QObject *parent)
                 : AbstractDomain(parent)
             {
             }
             XYDomain::~XYDomain()
             {
             }
             void XYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 bool axisXChanged = false;
                 bool axisYChanged = false;
                 if (!qFuzzyCompare(m_minX, minX) || !qFuzzyCompare(m_maxX, maxX)) {
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
                     if(!m_signalsBlocked)
                         emit rangeHorizontalChanged(m_minX, m_maxX);
                 }
                 if (!qFuzzyCompare(m_minY, minY) || !qFuzzyCompare(m_maxY, maxY)) {
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
                     if(!m_signalsBlocked)
                         emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                 if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void XYDomain::zoomIn(const QRectF &rect)
             {
                 storeZoomReset();
                 qreal dx = spanX() / m_size.width();
                 qreal dy = spanY() / m_size.height();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 maxX = minX + dx * rect.right();
                 minX = minX + dx * rect.left();
                 minY = maxY - dy * rect.bottom();
                 maxY = maxY - dy * rect.top();
                 if ((maxX - minX) == spanX()) {
                     minX = m_minX;
                     maxX = m_maxX;
                 }
                 if ((maxY - minY) == spanY()) {
                     minY = m_minY;
                     maxY = m_maxY;
                 }
                 setRange(minX, maxX, minY, maxY);
             }
             void XYDomain::zoomOut(const QRectF &rect)
             {
                 storeZoomReset();
                 qreal dx = spanX() / rect.width();
                 qreal dy = spanY() / rect.height();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 minX = maxX - dx * rect.right();
                 maxX = minX + dx * m_size.width();
                 maxY = minY + dy * rect.bottom();
                 minY = maxY - dy * m_size.height();
                 if ((maxX - minX) == spanX()) {
                     minX = m_minX;
                     maxX = m_maxX;
                 }
                 if ((maxY - minY) == spanY()) {
                     minY = m_minY;
                     maxY = m_maxY;
                 }
                 setRange(minX, maxX, minY, maxY);
             }
             void XYDomain::move(qreal dx, qreal dy)
             {
                 qreal x = spanX() / m_size.width();
                 qreal y = spanY() / m_size.height();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 if (dx != 0) {
                     minX = minX + x * dx;
                     maxX = maxX + x * dx;
                 }
                 if (dy != 0) {
                     minY = minY + y * dy;
                     maxY = maxY + y * dy;
                 }
                 setRange(minX, maxX, minY, maxY);
             }
             QPointF XYDomain::calculateGeometryPoint(const QPointF &point, bool &ok) 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();
                 ok = true;
                 return QPointF(x, y);
             }
-            QVector<QPointF> XYDomain::calculateGeometryPoints(const QList<QPointF> &vector) const
+            QVector<QPointF> XYDomain::calculateGeometryPoints(const QVector<QPointF> &vector) 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(vector.count());
                 for (int i = 0; i < vector.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 XYDomain::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);
             }
             // operators
             bool QT_CHARTS_AUTOTEST_EXPORT operator== (const XYDomain &domain1, const XYDomain &domain2)
             {
                 return (qFuzzyCompare(domain1.m_maxX, domain2.m_maxX)
                         && qFuzzyCompare(domain1.m_maxY, domain2.m_maxY)
                         && qFuzzyCompare(domain1.m_minX, domain2.m_minX)
                         && qFuzzyCompare(domain1.m_minY, domain2.m_minY));
             }
             bool QT_CHARTS_AUTOTEST_EXPORT operator!= (const XYDomain &domain1, const XYDomain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug QT_CHARTS_AUTOTEST_EXPORT operator<<(QDebug dbg, const XYDomain &domain)
             {
             #ifdef QT_NO_TEXTSTREAM
                 Q_UNUSED(domain)
             #else
                 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
             #endif
                 return dbg.maybeSpace();
             }
             #include "moc_xydomain_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/domain/xydomain_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 XYDOMAIN_H
             #define XYDOMAIN_H
             #include <private/abstractdomain_p.h>
             #include <QtCore/QRectF>
             #include <QtCore/QSizeF>
             QT_CHARTS_BEGIN_NAMESPACE
             class QT_CHARTS_AUTOTEST_EXPORT XYDomain: public AbstractDomain
             {
                 Q_OBJECT
             public:
                 explicit XYDomain(QObject *object = 0);
                 virtual ~XYDomain();
                 DomainType type(){ return AbstractDomain::XYDomain;}
                 void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 friend bool QT_CHARTS_AUTOTEST_EXPORT operator== (const XYDomain &Domain1, const XYDomain &Domain2);
                 friend bool QT_CHARTS_AUTOTEST_EXPORT operator!= (const XYDomain &Domain1, const XYDomain &Domain2);
                 friend QDebug QT_CHARTS_AUTOTEST_EXPORT operator<<(QDebug dbg, const XYDomain &AbstractDomain);
                 void zoomIn(const QRectF &rect);
                 void zoomOut(const QRectF &rect);
                 void move(qreal dx, qreal dy);
                 QPointF calculateGeometryPoint(const QPointF &point, bool &ok) const;
                 QPointF calculateDomainPoint(const QPointF &point) const;
-                QVector<QPointF> calculateGeometryPoints(const QList<QPointF> &vector) const;
+                QVector<QPointF> calculateGeometryPoints(const QVector<QPointF> &vector) const;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // XYDOMAIN_H

src/charts/linechart/linechartitem.cpp +14 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/linechartitem_p.h>
             #include <QtCharts/QLineSeries>
             #include <private/qlineseries_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/polardomain_p.h>
             #include <private/chartthememanager_p.h>
             #include <private/charttheme_p.h>
             #include <QtGui/QPainter>
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             QT_CHARTS_BEGIN_NAMESPACE
             const qreal mouseEventMinWidth(12);
             LineChartItem::LineChartItem(QLineSeries *series, QGraphicsItem *item)
                 : XYChart(series,item),
                   m_series(series),
                   m_pointsVisible(false),
                   m_chartType(QChart::ChartTypeUndefined),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFormat(series->pointLabelsFormat()),
                   m_pointLabelsFont(series->pointLabelsFont()),
                   m_pointLabelsColor(series->pointLabelsColor()),
                   m_pointLabelsClipping(true),
                   m_mousePressed(false)
             {
                 setAcceptHoverEvents(true);
                 setFlag(QGraphicsItem::ItemIsSelectable);
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsFormatChanged(QString)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsVisibilityChanged(bool)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsFontChanged(QFont)), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsColorChanged(QColor)), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsClippingChanged(bool)), this, SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF LineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_shapePath;
             }
             void LineChartItem::updateGeometry()
             {
+                static const QRectF dummyRect = QRectF(0.0, 0.0, 0.001, 0.001);
+                if (m_series->useOpenGL()) {
+                    // Fake a miniscule region, so we trigger changed signal.
+                    if (m_rect.width() != dummyRect.width()) {
+                        prepareGeometryChange();
+                        m_rect = dummyRect;
+                    }
+                    update();
+                    return;
+                }
                 // Store the points to a local variable so that the old line gets properly cleared
                 // when animation starts.
                 m_linePoints = geometryPoints();
                 const QVector<QPointF> &points = m_linePoints;
                 if (points.size() == 0) {
                     prepareGeometryChange();
                     m_fullPath = QPainterPath();
                     m_linePath = QPainterPath();
                     m_rect = QRect();
                     return;
                 }
                 QPainterPath linePath;
                 QPainterPath fullPath;
                 // Use worst case scenario to determine required margin.
                 qreal margin = m_linePen.width() * 1.42;
                 // Area series use component line series that aren't necessarily added to the chart themselves,
                 // so check if chart type is forced before trying to obtain it from the chart.
                 QChart::ChartType chartType = m_chartType;
                 if (chartType == QChart::ChartTypeUndefined)
                     chartType = m_series->chart()->chartType();
                 // For polar charts, we need special handling for angular (horizontal)
                 // points that are off-grid.
                 if (chartType == QChart::ChartTypePolar) {
                     QPainterPath linePathLeft;
                     QPainterPath linePathRight;
                     QPainterPath *currentSegmentPath = 0;
                     QPainterPath *previousSegmentPath = 0;
                     qreal minX = domain()->minX();
                     qreal maxX = domain()->maxX();
                     qreal minY = domain()->minY();
                     QPointF currentSeriesPoint = m_series->at(0);
                     QPointF currentGeometryPoint = points.at(0);
                     QPointF previousGeometryPoint = points.at(0);
                     int size = m_linePen.width();
                     bool pointOffGrid = false;
                     bool previousPointWasOffGrid = (currentSeriesPoint.x() < minX || currentSeriesPoint.x() > maxX);
                     qreal domainRadius = domain()->size().height() / 2.0;
                     const QPointF centerPoint(domainRadius, domainRadius);
                     if (!previousPointWasOffGrid) {
                         fullPath.moveTo(points.at(0));
                         if (m_pointsVisible && currentSeriesPoint.y() >= minY) {
                             // Do not draw ellipses for points below minimum Y.
                             linePath.addEllipse(points.at(0), size, size);
                             fullPath.addEllipse(points.at(0), size, size);
                             linePath.moveTo(points.at(0));
                             fullPath.moveTo(points.at(0));
                         }
                     }
                     qreal leftMarginLine = centerPoint.x() - margin;
                     qreal rightMarginLine = centerPoint.x() + margin;
                     qreal horizontal = centerPoint.y();
                     // See ScatterChartItem::updateGeometry() for explanation why seriesLastIndex is needed
                     const int seriesLastIndex = m_series->count() - 1;
                     for (int i = 1; i < points.size(); i++) {
                         // Interpolating line fragments would be ugly when thick pen is used,
                         // so we work around it by utilizing three separate
                         // paths for line segments and clip those with custom regions at paint time.
                         // "Right" path contains segments that cross the axis line with visible point on the
                         // right side of the axis line, as well as segments that have one point within the margin
                         // on the right side of the axis line and another point on the right side of the chart.
                         // "Left" path contains points with similarly on the left side.
                         // "Full" path contains rest of the points.
                         // This doesn't yield perfect results always. E.g. when segment covers more than 90
                         // degrees and both of the points are within the margin, one in the top half and one in the
                         // bottom half of the chart, the bottom one gets clipped incorrectly.
                         // However, this should be rare occurrence in any sensible chart.
                         currentSeriesPoint = m_series->at(qMin(seriesLastIndex, i));
                         currentGeometryPoint = points.at(i);
                         pointOffGrid = (currentSeriesPoint.x() < minX || currentSeriesPoint.x() > maxX);
                         // Draw something unless both off-grid
                         if (!pointOffGrid || !previousPointWasOffGrid) {
                             QPointF intersectionPoint;
                             qreal y;
                             if (pointOffGrid != previousPointWasOffGrid) {
                                 if (currentGeometryPoint.x() == previousGeometryPoint.x()) {
                                     y = currentGeometryPoint.y() + (currentGeometryPoint.y() - previousGeometryPoint.y()) / 2.0;
                                 } else {
                                     qreal ratio = (centerPoint.x() - currentGeometryPoint.x()) / (currentGeometryPoint.x() - previousGeometryPoint.x());
                                     y = currentGeometryPoint.y() + (currentGeometryPoint.y() - previousGeometryPoint.y()) * ratio;
                                 }
                                 intersectionPoint = QPointF(centerPoint.x(), y);
                             }
                             bool dummyOk; // We know points are ok, but this is needed
                             qreal currentAngle = 0;
                             qreal previousAngle = 0;
                             if (const PolarDomain *pd = qobject_cast<const PolarDomain *>(domain())) {
                                 currentAngle = pd->toAngularCoordinate(currentSeriesPoint.x(), dummyOk);
                                 previousAngle = pd->toAngularCoordinate(m_series->at(i - 1).x(), dummyOk);
                             } else {
                                 qWarning() << Q_FUNC_INFO << "Unexpected domain: " << domain();
                             }
                             if ((qAbs(currentAngle - previousAngle) > 180.0)) {
                                 // If the angle between two points is over 180 degrees (half X range),
                                 // any direct segment between them becomes meaningless.
                                 // In this case two line segments are drawn instead, from previous
                                 // point to the center and from center to current point.
                                 if ((previousAngle < 0.0 || (previousAngle <= 180.0 && previousGeometryPoint.x() < rightMarginLine))
                                     && previousGeometryPoint.y() < horizontal) {
                                     currentSegmentPath = &linePathRight;
                                 } else if ((previousAngle > 360.0 || (previousAngle > 180.0 && previousGeometryPoint.x() > leftMarginLine))
                                             && previousGeometryPoint.y() < horizontal) {
                                     currentSegmentPath = &linePathLeft;
                                 } else if (previousAngle > 0.0 && previousAngle < 360.0) {
                                     currentSegmentPath = &linePath;
                                 } else {
                                     currentSegmentPath = 0;
                                 }
                                 if (currentSegmentPath) {
                                     if (previousSegmentPath != currentSegmentPath)
                                         currentSegmentPath->moveTo(previousGeometryPoint);
                                     if (previousPointWasOffGrid)
                                         fullPath.moveTo(intersectionPoint);
                                     currentSegmentPath->lineTo(centerPoint);
                                     fullPath.lineTo(centerPoint);
                                 }
                                 previousSegmentPath = currentSegmentPath;
                                 if ((currentAngle < 0.0 || (currentAngle <= 180.0 && currentGeometryPoint.x() < rightMarginLine))
                                     && currentGeometryPoint.y() < horizontal) {
                                     currentSegmentPath = &linePathRight;
                                 } else if ((currentAngle > 360.0 || (currentAngle > 180.0 &&currentGeometryPoint.x() > leftMarginLine))
                                             && currentGeometryPoint.y() < horizontal) {
                                     currentSegmentPath = &linePathLeft;
                                 } else if (currentAngle > 0.0 && currentAngle < 360.0) {
                                     currentSegmentPath = &linePath;
                                 } else {
                                     currentSegmentPath = 0;
                                 }
                                 if (currentSegmentPath) {
                                     if (previousSegmentPath != currentSegmentPath)
                                         currentSegmentPath->moveTo(centerPoint);
                                     if (!previousSegmentPath)
                                         fullPath.moveTo(centerPoint);
                                     currentSegmentPath->lineTo(currentGeometryPoint);
                                     if (pointOffGrid)
                                         fullPath.lineTo(intersectionPoint);
                                     else
                                         fullPath.lineTo(currentGeometryPoint);
                                 }
                             } else {
                                 if (previousAngle < 0.0 || currentAngle < 0.0
                                     || ((previousAngle <= 180.0 && currentAngle <= 180.0)
                                         && ((previousGeometryPoint.x() < rightMarginLine && previousGeometryPoint.y() < horizontal)
                                             || (currentGeometryPoint.x() < rightMarginLine && currentGeometryPoint.y() < horizontal)))) {
                                     currentSegmentPath = &linePathRight;
                                 } else if (previousAngle > 360.0 || currentAngle > 360.0
                                            || ((previousAngle > 180.0 && currentAngle > 180.0)
                                                && ((previousGeometryPoint.x() > leftMarginLine && previousGeometryPoint.y() < horizontal)
                                                    || (currentGeometryPoint.x() > leftMarginLine && currentGeometryPoint.y() < horizontal)))) {
                                     currentSegmentPath = &linePathLeft;
                                 } else {
                                     currentSegmentPath = &linePath;
                                 }
                                 if (currentSegmentPath != previousSegmentPath)
                                     currentSegmentPath->moveTo(previousGeometryPoint);
                                 if (previousPointWasOffGrid)
                                     fullPath.moveTo(intersectionPoint);
                                 if (pointOffGrid)
                                     fullPath.lineTo(intersectionPoint);
                                 else
                                     fullPath.lineTo(currentGeometryPoint);
                                 currentSegmentPath->lineTo(currentGeometryPoint);
                             }
                         } else {
                             currentSegmentPath = 0;
                         }
                         previousPointWasOffGrid = pointOffGrid;
                         if (m_pointsVisible && !pointOffGrid && currentSeriesPoint.y() >= minY) {
                             linePath.addEllipse(points.at(i), size, size);
                             fullPath.addEllipse(points.at(i), size, size);
                             linePath.moveTo(points.at(i));
                             fullPath.moveTo(points.at(i));
                         }
                         previousSegmentPath = currentSegmentPath;
                         previousGeometryPoint = currentGeometryPoint;
                     }
                     m_linePathPolarRight = linePathRight;
                     m_linePathPolarLeft = linePathLeft;
                     // Note: This construction of m_fullpath is not perfect. The partial segments that are
                     // outside left/right clip regions at axis boundary still generate hover/click events,
                     // because shape doesn't get clipped. It doesn't seem possible to do sensibly.
                 } else { // not polar
                     linePath.moveTo(points.at(0));
                     if (m_pointsVisible) {
                         int size = m_linePen.width();
                         linePath.addEllipse(points.at(0), size, size);
                         linePath.moveTo(points.at(0));
                         for (int i = 1; i < points.size(); i++) {
                             linePath.lineTo(points.at(i));
                             linePath.addEllipse(points.at(i), size, size);
                             linePath.moveTo(points.at(i));
                         }
                     } else {
                         for (int i = 1; i < points.size(); i++)
                             linePath.lineTo(points.at(i));
                     }
                     fullPath = linePath;
                 }
                 QPainterPathStroker stroker;
                 // QPainter::drawLine does not respect join styles, for example BevelJoin becomes MiterJoin.
                 // This is why we are prepared for the "worst case" scenario, i.e. use always MiterJoin and
                 // multiply line width with square root of two when defining shape and bounding rectangle.
                 stroker.setWidth(margin);
                 stroker.setJoinStyle(Qt::MiterJoin);
                 stroker.setCapStyle(Qt::SquareCap);
                 stroker.setMiterLimit(m_linePen.miterLimit());
                 QPainterPath checkShapePath = stroker.createStroke(fullPath);
                 // Only zoom in if the bounding rects of the paths fit inside int limits. QWidget::update() uses
                 // a region that has to be compatible with QRect.
                 if (checkShapePath.boundingRect().height() <= INT_MAX
                         && checkShapePath.boundingRect().width() <= INT_MAX
                         && linePath.boundingRect().height() <= INT_MAX
                         && linePath.boundingRect().width() <= INT_MAX
                         && fullPath.boundingRect().height() <= INT_MAX
                         && fullPath.boundingRect().width() <= INT_MAX) {
                     prepareGeometryChange();
                     m_linePath = linePath;
                     m_fullPath = fullPath;
                     m_shapePath = checkShapePath;
                     m_rect = m_shapePath.boundingRect();
                 } else {
                     update();
                 }
             }
             void LineChartItem::handleUpdated()
             {
                 // If points visibility has changed, a geometry update is needed.
                 // Also, if pen changes when points are visible, geometry update is needed.
                 bool doGeometryUpdate =
                     (m_pointsVisible != m_series->pointsVisible())
                     || (m_series->pointsVisible() && (m_linePen != m_series->pen()));
                 setVisible(m_series->isVisible());
                 setOpacity(m_series->opacity());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_pointLabelsFormat = m_series->pointLabelsFormat();
                 m_pointLabelsVisible = m_series->pointLabelsVisible();
                 m_pointLabelsFont = m_series->pointLabelsFont();
                 m_pointLabelsColor = m_series->pointLabelsColor();
                 m_pointLabelsClipping = m_series->pointLabelsClipping();
                 if (doGeometryUpdate)
                     updateGeometry();
                 update();
             }
             void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
+                if (m_series->useOpenGL())
+                    return;
                 QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
                 painter->save();
                 painter->setPen(m_linePen);
                 bool alwaysUsePath = false;
                 if (m_series->chart()->chartType() == QChart::ChartTypePolar) {
                     qreal halfWidth = domain()->size().width() / 2.0;
                     QRectF clipRectLeft = QRectF(0, 0, halfWidth, domain()->size().height());
                     QRectF clipRectRight = QRectF(halfWidth, 0, halfWidth, domain()->size().height());
                     QRegion fullPolarClipRegion(clipRect.toRect(), QRegion::Ellipse);
                     QRegion clipRegionLeft(fullPolarClipRegion.intersected(clipRectLeft.toRect()));
                     QRegion clipRegionRight(fullPolarClipRegion.intersected(clipRectRight.toRect()));
                     painter->setClipRegion(clipRegionLeft);
                     painter->drawPath(m_linePathPolarLeft);
                     painter->setClipRegion(clipRegionRight);
                     painter->drawPath(m_linePathPolarRight);
                     painter->setClipRegion(fullPolarClipRegion);
                     alwaysUsePath = true; // required for proper clipping
                 } else {
                     painter->setClipRect(clipRect);
                 }
                 reversePainter(painter, clipRect);
                 if (m_pointsVisible) {
                     painter->setBrush(m_linePen.color());
                     painter->drawPath(m_linePath);
                 } else {
                     painter->setBrush(QBrush(Qt::NoBrush));
                     if (m_linePen.style() != Qt::SolidLine || alwaysUsePath) {
                         // If pen style is not solid line, always fall back to path painting
                         // to ensure proper continuity of the pattern
                         painter->drawPath(m_linePath);
                     } else {
                         for (int i(1); i < m_linePoints.size(); i++)
                             painter->drawLine(m_linePoints.at(i - 1), m_linePoints.at(i));
                     }
                 }
                 reversePainter(painter, clipRect);
                 if (m_pointLabelsVisible) {
                     if (m_pointLabelsClipping)
                         painter->setClipping(true);
                     else
                         painter->setClipping(false);
                     m_series->d_func()->drawSeriesPointLabels(painter, m_linePoints, m_linePen.width() / 2);
                 }
                 painter->restore();
             }
             void LineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::pressed(domain()->calculateDomainPoint(event->pos()));
                 m_lastMousePos = event->pos();
                 m_mousePressed = true;
                 QGraphicsItem::mousePressEvent(event);
             }
             void LineChartItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), true);
             //    event->accept();
                 QGraphicsItem::hoverEnterEvent(event);
             }
             void LineChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), false);
             //    event->accept();
                 QGraphicsItem::hoverEnterEvent(event);
             }
             void LineChartItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::released(domain()->calculateDomainPoint(m_lastMousePos));
                 if (m_mousePressed)
                     emit XYChart::clicked(domain()->calculateDomainPoint(m_lastMousePos));
                 m_mousePressed = false;
                 QGraphicsItem::mouseReleaseEvent(event);
             }
             void LineChartItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::doubleClicked(domain()->calculateDomainPoint(m_lastMousePos));
                 QGraphicsItem::mouseDoubleClickEvent(event);
             }
             #include "moc_linechartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/qabstractseries.cpp +97 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtCharts/QAbstractSeries>
             #include <private/qabstractseries_p.h>
             #include <private/chartdataset_p.h>
             #include <QtCharts/QChart>
             #include <private/qchart_p.h>
             #include <private/chartitem_p.h>
             #include <private/xydomain_p.h>
             #include <private/xlogydomain_p.h>
             #include <private/logxydomain_p.h>
             #include <private/logxlogydomain_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QAbstractSeries
                 \inmodule Qt Charts
                 \brief Base class for all Qt Chart series.
                 Usually you use the series type specific inherited classes instead of the base class.
                 \sa QXYSeries, QLineSeries, QSplineSeries, QScatterSeries, QAreaSeries, QAbstractBarSeries, QStackedBarSeries,
                 QPercentBarSeries, QPieSeries
             */
             /*!
                 \qmltype AbstractSeries
                 \instantiates QAbstractSeries
                 \inqmlmodule QtCharts
                 \brief Base class for all Qt Chart series.
                 AbstractSeries is the base class for all series.
                 The class cannot be instantiated by the user.
             */
             /*!
                 \enum QAbstractSeries::SeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
                 \value SeriesTypeHorizontalBar
                 \value SeriesTypeHorizontalStackedBar
                 \value SeriesTypeHorizontalPercentBar
                 \value SeriesTypeBoxPlot
             */
             /*!
                 \property QAbstractSeries::type
                 The type of the series.
             */
             /*!
                 \qmlproperty ChartView.SeriesType AbstractSeries::type
                 The type of the series.
             */
             /*!
                 \property QAbstractSeries::name
                 \brief name of the series property. The name is shown in legend for series and supports html formatting.
             */
             /*!
                 \qmlproperty string AbstractSeries::name
                 Name of the series. The name is shown in legend for series and supports html formatting.
             */
             /*!
                 \fn void QAbstractSeries::nameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onNameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \property QAbstractSeries::visible
                 \brief whether the series is visible or not; true by default.
             */
             /*!
                 \qmlproperty bool AbstractSeries::visible
                 Visibility of the series. True by default.
             */
             /*!
                 \fn void QAbstractSeries::visibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onVisibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \property QAbstractSeries::opacity
                 \brief The opacity of the series.
                 By default the opacity is 1.0. The valid values range from 0.0 (transparent) to 1.0 (opaque).
             */
             /*!
                 \qmlproperty real AbstractSeries::opacity
                 The opacity of the series. By default the opacity is 1.0.
                 The valid values range from 0.0 (transparent) to 1.0 (opaque).
             */
             /*!
                 \fn void QAbstractSeries::opacityChanged()
                 Emitted when the opacity of the series changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onOpacityChanged()
                 Emitted when the opacity of the series changes.
             */
             /*!
+                \property QAbstractSeries::useOpenGL
+                \brief Specifies whether or not the series drawing is accelerated with OpenGL.
+                Drawing series with OpenGL is supported only for QLineSeries and QScatterSeries.
+                Line series used as edge series for a QAreaSeries cannot use OpenGL acceleration.
+                When a chart contains any series that are drawn with OpenGL, a transparent QOpenGLWidget
+                is created on top of the chart plot area. Specified series are not drawn on the underlying
+                QGraphicsView, but are instead drawn on the created QOpenGLWidget.
+                Performance gained from using OpenGL to accelerate series drawing depends on the underlying
+                hardware, but in most cases it is significant. For example, on a standard desktop computer,
+                enabling OpenGL acceleration for a series typically allows rendering at least hundred times
+                more points without reduction on the frame rate.
+                Chart size also has less effect on the frame rate.
+                The OpenGL acceleration of series drawing is meant for use cases that need fast drawing of
+                large numbers of points. It is optimized for efficiency, and therefore the series using
+                it lack support for some features available to non-accelerated series.
+                There are the following restrictions imposed on charts and series when using OpenGL
+                acceleration:
+                \list
+                \li Series animations are not supported for accelerated series.
+                \li Antialiasing is not supported for accelerated series.
+                \li Pen styles and marker shapes are ignored for accelerated series.
+                    Only solid lines and plain scatter dots are supported.
+                    The scatter dots may be circular or rectangular, depending on the underlying graphics
+                    hardware and drivers.
+                \li Polar charts are not supported for accelerated series.
+                \li Since the accelerated series are drawn on top of the entire graphics view, they get drawn
+                    on top of any other graphics items that you may have on top chart in the same scene.
+                \li To enable QOpenGLWidget to be partially transparent, it needs to be stacked on top of
+                    all other widgets. This means you cannot have other widgets partially covering the
+                    chart.
+                \endlist
+                The default value is \c{false}.
+            */
+            /*!
+                \qmlproperty bool AbstractSeries::useOpenGL
+                Specifies whether or not the series is drawn with OpenGL.
+                Drawing series with OpenGL is supported only for LineSeries and ScatterSeries.
+                For more details, see QAbstractSeries::useOpenGL documentation. QML applications have similar
+                restrictions as those listed in QAbstractSeries::useOpenGL documentation,
+                except there is no restriction about covering the ChartView partially with other
+                items due to different rendering mechanism.
+                The default value is \c{false}.
+            */
+            /*!
+                \fn void QAbstractSeries::useOpenGLChanged()
+                Emitted when the useOpenGL property value changes.
+            */
+            /*!
+                \qmlsignal AbstractSeries::onUseOpenGLChanged()
+                Emitted when the useOpenGL property value changes.
+            */
+            /*!
                 \internal
                 \brief Constructs QAbstractSeries object with \a parent.
             */
             QAbstractSeries::QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent) :
                 QObject(parent),
                 d_ptr(&d)
             {
             }
             /*!
                 \brief Virtual destructor for the chart series.
             */
             QAbstractSeries::~QAbstractSeries()
             {
                 if (d_ptr->m_chart)
                     qFatal("Series still bound to a chart when destroyed!");
             }
             void QAbstractSeries::setName(const QString &name)
             {
                 if (name != d_ptr->m_name) {
                     d_ptr->m_name = name;
                     emit nameChanged();
                 }
             }
             QString QAbstractSeries::name() const
             {
                 return d_ptr->m_name;
             }
             void QAbstractSeries::setVisible(bool visible)
             {
                 if (visible != d_ptr->m_visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged();
                 }
             }
             bool QAbstractSeries::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             qreal QAbstractSeries::opacity() const
             {
                 return d_ptr->m_opacity;
             }
             void QAbstractSeries::setOpacity(qreal opacity)
             {
                 if (opacity != d_ptr->m_opacity) {
                     d_ptr->m_opacity = opacity;
                     emit opacityChanged();
                 }
             }
+            void QAbstractSeries::setUseOpenGL(bool enable)
+            {
+            #ifdef QT_NO_OPENGL
+                Q_UNUSED(enable)
+            #else
+                bool polarChart = d_ptr->m_chart && d_ptr->m_chart->chartType() == QChart::ChartTypePolar;
+                bool supportedSeries = (type() == SeriesTypeLine || type() == SeriesTypeScatter);
+                if ((!enable || !d_ptr->m_blockOpenGL)
+                        && supportedSeries
+                        && enable != d_ptr->m_useOpenGL
+                        && (!enable || !polarChart)) {
+                    d_ptr->m_useOpenGL = enable;
+                    emit useOpenGLChanged();
+                }
+            #endif
+            }
+            bool QAbstractSeries::useOpenGL() const
+            {
+                return d_ptr->m_useOpenGL;
+            }
             /*!
                 \brief Returns the chart where series belongs to.
                 Set automatically when the series is added to the chart
                 and unset when the series is removed from the chart.
             */
             QChart *QAbstractSeries::chart() const
             {
                 return d_ptr->m_chart;
             }
             /*!
                 \brief Sets the visibility of the series to true.
                 \sa setVisible(), isVisible()
             */
             void QAbstractSeries::show()
             {
                 setVisible(true);
             }
             /*!
                 \brief Sets the visibility of the series to false.
                 \sa setVisible(), isVisible()
             */
             void QAbstractSeries::hide()
             {
                 setVisible(false);
             }
             /*!
              Attach \a axis to the series.
              \return true if the axis was attached successfully, false otherwise.
              \note If multiple axes of same orientation are attached to same series,
                    they will have same min/max ranges.
              \sa QChart::addAxis(), QChart::createDefaultAxes()
              */
             bool QAbstractSeries::attachAxis(QAbstractAxis* axis)
             {
                 if(d_ptr->m_chart) {
                     return d_ptr->m_chart->d_ptr->m_dataset->attachAxis(this, axis);
                 } else {
                     qWarning()<<"Series not in the chart. Please addSeries to chart first.";
                     return false;
                 }
             }
             /*!
              Detach \a axis from the series.
              \return true if the axis was detached successfully, false otherwise.
              \sa QChart::removeAxis()
              */
             bool QAbstractSeries::detachAxis(QAbstractAxis* axis)
             {
                 if(d_ptr->m_chart) {
                     return d_ptr->m_chart->d_ptr->m_dataset->detachAxis(this, axis);
                 }
                 else {
                     qWarning()<<"Series not in the chart. Please addSeries to chart first.";
                     return false;
                 }
             }
             /*!
              Returns the list of axes attached to the series. Usually there is an x-axis and a y-axis attached to a series, except
              in case of a QPieSeries, which does not have any axes attached.
              \sa attachAxis(), detachAxis()
              */
             QList<QAbstractAxis*> QAbstractSeries::attachedAxes()
             {
                 return d_ptr->m_axes;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries *q)
                 : q_ptr(q),
                   m_chart(0),
                   m_item(0),
                   m_domain(new XYDomain()),
                   m_visible(true),
-                  m_opacity(1.0)
+                  m_opacity(1.0),
+                  m_useOpenGL(false),
+                  m_blockOpenGL(false)
             {
             }
             QAbstractSeriesPrivate::~QAbstractSeriesPrivate()
             {
             }
             void QAbstractSeriesPrivate::setDomain(AbstractDomain* domain)
             {
                 Q_ASSERT(domain);
                 if(m_domain.data()!=domain) {
                     if(!m_item.isNull()) QObject::disconnect(m_domain.data(), SIGNAL(updated()), m_item.data(), SLOT(handleDomainUpdated()));
                     m_domain.reset(domain);
                     if(!m_item.isNull()) {
                         QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
                         m_item->handleDomainUpdated();
                     }
                 }
             }
             void QAbstractSeriesPrivate::setPresenter(ChartPresenter *presenter)
             {
                 m_presenter = presenter;
             }
             ChartPresenter *QAbstractSeriesPrivate::presenter() const
             {
                 return m_presenter;
             }
             void QAbstractSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_ASSERT(!m_item.isNull());
                 Q_UNUSED(parent);
                 QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
             }
             void QAbstractSeriesPrivate::initializeAnimations(QChart::AnimationOptions options, int duration,
                                                               QEasingCurve &curve)
             {
                 Q_UNUSED(options);
                 Q_UNUSED(duration);
                 Q_UNUSED(curve);
             }
             bool QAbstractSeriesPrivate::reverseXAxis()
             {
                 bool reverseXAxis = false;
                 if (m_axes.size() != 0 && !(m_chart->chartType() == QChart::ChartTypePolar)) {
                     int i = 0;
                     while (i < m_axes.size()) {
                         if (m_axes.at(i)->orientation() == Qt::Horizontal && m_axes.at(i)->isReverse()) {
                             reverseXAxis = true;
                             break;
                         }
                         i++;
                     }
                 }
                 return reverseXAxis;
             }
             bool QAbstractSeriesPrivate::reverseYAxis()
             {
                 bool reverseYAxis = false;
                 if (m_axes.size() != 0 && !(m_chart->chartType() == QChart::ChartTypePolar)) {
                     int i = 0;
                     while (i < m_axes.size()) {
                         if (m_axes.at(i)->orientation() == Qt::Vertical && m_axes.at(i)->isReverse()) {
                             reverseYAxis = true;
                             break;
                         }
                         i++;
                     }
                 }
                 return reverseYAxis;
             }
+            // This function can be used to explicitly block OpenGL use from some otherwise supported series,
+            // such as the line series used as edge series of an area series.
+            void QAbstractSeriesPrivate::setBlockOpenGL(bool enable)
+            {
+                m_blockOpenGL = enable;
+                if (enable)
+                    q_ptr->setUseOpenGL(false);
+            }
             #include "moc_qabstractseries.cpp"
             #include "moc_qabstractseries_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/qabstractseries.h +5 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #ifndef QABSTRACTSERIES_H
             #define QABSTRACTSERIES_H
             #include <QtCharts/QChartGlobal>
             #include <QtCharts/QAbstractAxis>
             #include <QtCore/QObject>
             #include <QtGui/QPen>
             QT_CHARTS_BEGIN_NAMESPACE
             class QAbstractSeriesPrivate;
             class QChart;
             class QT_CHARTS_EXPORT QAbstractSeries : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
                 Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged)
                 Q_PROPERTY(qreal opacity READ opacity WRITE setOpacity NOTIFY opacityChanged)
                 Q_PROPERTY(SeriesType type READ type)
+                Q_PROPERTY(bool useOpenGL READ useOpenGL WRITE setUseOpenGL NOTIFY useOpenGLChanged)
                 Q_ENUMS(SeriesType)
             public:
                 enum SeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline,
                     SeriesTypeHorizontalBar,
                     SeriesTypeHorizontalStackedBar,
                     SeriesTypeHorizontalPercentBar,
                     SeriesTypeBoxPlot
                 };
             protected:
                 QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent = 0);
             public:
                 ~QAbstractSeries();
                 virtual SeriesType type() const = 0;
                 void setName(const QString &name);
                 QString name() const;
                 void setVisible(bool visible = true);
                 bool isVisible() const;
                 qreal opacity() const;
                 void setOpacity(qreal opacity);
+                void setUseOpenGL(bool enable = true);
+                bool useOpenGL() const;
                 QChart *chart() const;
                 bool attachAxis(QAbstractAxis *axis);
                 bool detachAxis(QAbstractAxis *axis);
                 QList<QAbstractAxis*> attachedAxes();
                 void show();
                 void hide();
             Q_SIGNALS:
                 void nameChanged();
                 void visibleChanged();
                 void opacityChanged();
+                void useOpenGLChanged();
             protected:
                 QScopedPointer<QAbstractSeriesPrivate> d_ptr;
                 friend class ChartDataSet;
                 friend class ChartPresenter;
                 friend class ChartThemeManager;
                 friend class QLegendPrivate;
                 friend class DeclarativeChart;
+                friend class QAreaSeries;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QABSTRACTSERIES_H

src/charts/qabstractseries_p.h +4 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 QABSTRACTSERIES_P_H
             #define QABSTRACTSERIES_P_H
             #include <QtCharts/QAbstractSeries>
             #include <QtCharts/QChart>
             #include <private/abstractdomain_p.h>
             QT_BEGIN_NAMESPACE
             class QGraphicsItem;
             QT_END_NAMESPACE
             QT_CHARTS_BEGIN_NAMESPACE
             class ChartPresenter;
             class ChartElement;
             class LegendMarker;
             class QLegend;
             class ChartDataSet;
             class QAbstractAxis;
             class QLegendMarker;
             class ChartTheme;
             class ChartAnimation;
             class ChartItem;
             class BoxPlotChartItem;
             class QAbstractSeriesPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QAbstractSeriesPrivate(QAbstractSeries *q);
                 ~QAbstractSeriesPrivate();
                 virtual void initializeDomain() = 0;
                 virtual void initializeAxes() = 0;
                 virtual void initializeTheme(int index, ChartTheme* theme, bool forced = false) = 0;
                 virtual void initializeGraphics(QGraphicsItem* parent) = 0;
                 virtual void initializeAnimations(QChart::AnimationOptions options, int duration,
                                                   QEasingCurve &curve) = 0;
                 virtual QList<QLegendMarker*> createLegendMarkers(QLegend* legend) = 0;
                 virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation) const = 0;
                 virtual QAbstractAxis* createDefaultAxis(Qt::Orientation) const = 0;
                 ChartItem* chartItem() { return m_item.data(); }
                 virtual void setDomain(AbstractDomain* domain);
                 AbstractDomain* domain() { return m_domain.data(); }
                 virtual void setPresenter(ChartPresenter *presenter);
                 ChartPresenter *presenter() const;
                 QChart* chart() { return m_chart; }
                 bool reverseXAxis();
                 bool reverseYAxis();
+                void setBlockOpenGL(bool enable);
             Q_SIGNALS:
                 void countChanged();
             protected:
                 QAbstractSeries *q_ptr;
                 QChart *m_chart;
                 QScopedPointer<ChartItem> m_item;
                 QList<QAbstractAxis*> m_axes;
             private:
                 QScopedPointer<AbstractDomain> m_domain;
                 QString m_name;
                 bool m_visible;
                 qreal m_opacity;
                 ChartPresenter *m_presenter;
+                bool m_useOpenGL;
+                bool m_blockOpenGL;
                 friend class QAbstractSeries;
                 friend class ChartDataSet;
                 friend class ChartPresenter;
                 friend class QLegendPrivate;
                 friend class BoxPlotChartItem;
             };
             QT_CHARTS_END_NAMESPACE
             #endif

src/charts/scatterchart/scatterchartitem.cpp +15 0

             /****************************************************************************
              **
              ** Copyright (C) 2015 The Qt Company Ltd
              ** All rights reserved.
              ** For any questions to The Qt Company, please use contact form at http://qt.io
              **
              ** This file is part of the Qt Charts module.
              **
              ** Licensees holding valid commercial license for Qt may use this file in
              ** accordance with the Qt License Agreement provided with the Software
              ** or, alternatively, in accordance with the terms contained in a written
              ** agreement between you and The Qt Company.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.io
              **
              ****************************************************************************/
             #include <private/scatterchartitem_p.h>
             #include <QtCharts/QScatterSeries>
             #include <private/qscatterseries_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/abstractdomain_p.h>
             #include <QtCharts/QChart>
             #include <QtGui/QPainter>
             #include <QtWidgets/QGraphicsScene>
             #include <QtCore/QDebug>
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             QT_CHARTS_BEGIN_NAMESPACE
             ScatterChartItem::ScatterChartItem(QScatterSeries *series, QGraphicsItem *item)
                 : XYChart(series,item),
                   m_series(series),
                   m_items(this),
                   m_visible(true),
                   m_shape(QScatterSeries::MarkerShapeRectangle),
                   m_size(15),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFormat(series->pointLabelsFormat()),
                   m_pointLabelsFont(series->pointLabelsFont()),
                   m_pointLabelsColor(series->pointLabelsColor()),
                   m_pointLabelsClipping(true),
                   m_mousePressed(false)
             {
                 QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsFormatChanged(QString)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsVisibilityChanged(bool)),
                                  this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsFontChanged(QFont)), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsColorChanged(QColor)), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(pointLabelsClippingChanged(bool)), this, SLOT(handleUpdated()));
                 setZValue(ChartPresenter::ScatterSeriesZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 handleUpdated();
                 m_items.setHandlesChildEvents(false);
             }
             QRectF ScatterChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void ScatterChartItem::createPoints(int count)
             {
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item = 0;
                     switch (m_shape) {
                     case QScatterSeries::MarkerShapeCircle: {
                         item = new CircleMarker(0, 0, m_size, m_size, this);
                         const QRectF &rect = item->boundingRect();
                         item->setPos(-rect.width() / 2, -rect.height() / 2);
                         break;
                     }
                     case QScatterSeries::MarkerShapeRectangle:
                         item = new RectangleMarker(0, 0, m_size, m_size, this);
                         item->setPos(-m_size / 2, -m_size / 2);
                         break;
                     default:
                         qWarning() << "Unsupported marker type";
                         break;
                     }
                     m_items.addToGroup(item);
                 }
             }
             void ScatterChartItem::deletePoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item = items.takeLast();
                     m_markerMap.remove(item);
                     delete(item);
                 }
             }
             void ScatterChartItem::markerSelected(QGraphicsItem *marker)
             {
                 emit XYChart::clicked(m_markerMap[marker]);
             }
             void ScatterChartItem::markerHovered(QGraphicsItem *marker, bool state)
             {
                 emit XYChart::hovered(m_markerMap[marker], state);
             }
             void ScatterChartItem::markerPressed(QGraphicsItem *marker)
             {
                 emit XYChart::pressed(m_markerMap[marker]);
             }
             void ScatterChartItem::markerReleased(QGraphicsItem *marker)
             {
                 emit XYChart::released(m_markerMap[marker]);
             }
             void ScatterChartItem::markerDoubleClicked(QGraphicsItem *marker)
             {
                 emit XYChart::doubleClicked(m_markerMap[marker]);
             }
             void ScatterChartItem::updateGeometry()
             {
+                static const QRectF dummyRect = QRectF(0.0, 0.0, 0.001, 0.001);
+                if (m_series->useOpenGL()) {
+                    if (m_items.childItems().count())
+                        deletePoints(m_items.childItems().count());
+                    // Fake a miniscule region, so we trigger changed signal.
+                    if (m_rect.width() != dummyRect.width()) {
+                        prepareGeometryChange();
+                        m_rect = dummyRect;
+                    }
+                    update();
+                    return;
+                }
                 const QVector<QPointF>& points = geometryPoints();
                 if (points.size() == 0) {
                     deletePoints(m_items.childItems().count());
                     return;
                 }
                 int diff = m_items.childItems().size() - points.size();
                 if (diff > 0)
                     deletePoints(diff);
                 else if (diff < 0)
                     createPoints(-diff);
                 if (diff != 0)
                     handleUpdated();
                 QList<QGraphicsItem *> items = m_items.childItems();
                 QRectF clipRect(QPointF(0,0),domain()->size());
                 // Only zoom in if the clipRect fits inside int limits. QWidget::update() uses
                 // a region that has to be compatible with QRect.
                 if (clipRect.height() <= INT_MAX
                         && clipRect.width() <= INT_MAX) {
                     QVector<bool> offGridStatus = offGridStatusVector();
                     const int seriesLastIndex = m_series->count() - 1;
                     for (int i = 0; i < points.size(); i++) {
                         QGraphicsItem *item = items.at(i);
                         const QPointF &point = points.at(i);
                         const QRectF &rect = item->boundingRect();
                         // During remove animation series may have different number of points,
                         // so ensure we don't go over the index. Animation handling itself ensures that
                         // if there is actually no points in the series, then it won't generate a fake point,
                         // so we can be assured there is always at least one point in m_series here.
                         // Note that marker map values can be technically incorrect during the animation,
                         // if it was caused by an insert, but this shouldn't be a problem as the points are
                         // fake anyway. After remove animation stops, geometry is updated to correct one.
                         m_markerMap[item] = m_series->at(qMin(seriesLastIndex, i));
                         QPointF position;
                         if (seriesPrivate()->reverseXAxis())
                             position.setX(domain()->size().width() - point.x() - rect.width() / 2);
                         else
                             position.setX(point.x() - rect.width() / 2);
                         if (seriesPrivate()->reverseYAxis())
                             position.setY(domain()->size().height() - point.y() - rect.height() / 2);
                         else
                             position.setY(point.y() - rect.height() / 2);
                         item->setPos(position);
                         if (!m_visible || offGridStatus.at(i))
                             item->setVisible(false);
                         else
                             item->setVisible(true);
                     }
                     prepareGeometryChange();
                     m_rect = clipRect;
                 }
             }
             void ScatterChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
+                if (m_series->useOpenGL())
+                    return;
                 QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
                 painter->save();
                 painter->setClipRect(clipRect);
                 if (m_pointLabelsVisible) {
                     if (m_pointLabelsClipping)
                         painter->setClipping(true);
                     else
                         painter->setClipping(false);
                     m_series->d_func()->drawSeriesPointLabels(painter, m_points,
                                                               m_series->markerSize() / 2
                                                               + m_series->pen().width());
                 }
                 painter->restore();
             }
             void ScatterChartItem::setPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_items.childItems())
                     static_cast<QAbstractGraphicsShapeItem*>(item)->setPen(pen);
             }
             void ScatterChartItem::setBrush(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_items.childItems())
                     static_cast<QAbstractGraphicsShapeItem*>(item)->setBrush(brush);
             }
             void ScatterChartItem::handleUpdated()
             {
                 int count = m_items.childItems().count();
                 if (count == 0)
                     return;
                 bool recreate = m_visible != m_series->isVisible()
                                 || m_size != m_series->markerSize()
                                 || m_shape != m_series->markerShape();
                 m_visible = m_series->isVisible();
                 m_size = m_series->markerSize();
                 m_shape = m_series->markerShape();
                 setOpacity(m_series->opacity());
                 m_pointLabelsFormat = m_series->pointLabelsFormat();
                 m_pointLabelsVisible = m_series->pointLabelsVisible();
                 m_pointLabelsFont = m_series->pointLabelsFont();
                 m_pointLabelsColor = m_series->pointLabelsColor();
                 m_pointLabelsClipping = m_series->pointLabelsClipping();
                 if (recreate) {
                     deletePoints(count);
                     createPoints(count);
                     // Updating geometry is now safe, because it won't call handleUpdated unless it creates/deletes points
                     updateGeometry();
                 }
                 setPen(m_series->pen());
                 setBrush(m_series->brush());
                 update();
             }
             #include "moc_scatterchartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

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

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <QtCharts/QXYSeries>
             #include <private/qxyseries_p.h>
             #include <private/abstractdomain_p.h>
             #include <QtCharts/QValueAxis>
             #include <private/xychart_p.h>
             #include <QtCharts/QXYLegendMarker>
             #include <private/charthelpers_p.h>
             #include <private/qchart_p.h>
             #include <QtGui/QPainter>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \inmodule Qt Charts
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                 \qmltype XYSeries
                 \instantiates QXYSeries
                 \inqmlmodule QtCharts
                 \inherits AbstractSeries
                 \brief The XYSeries type is a base type for line, spline and scatter series.
                 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 pen(), 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.
             */
             /*!
                 \property QXYSeries::pointLabelsFormat
                 The \a format used for showing labels with series points.
                 QXYSeries supports the following format tags:
                 \table
                   \row
                     \li @xPoint      \li The x value of the data point
                   \row
                     \li @yPoint      \li The y value of the data point
                 \endtable
                 For example, the following usage of the format tags would produce labels that have the data
                 point (x, y) shown inside brackets separated by a comma:
                 \code
                 series->setPointLabelsFormat("(@xPoint, @yPoint)");
                 \endcode
                 By default, the labels format is set to '@xPoint, @yPoint'. The labels are shown on the plot
                 area, labels on the edge of the plot area are cut. If the points are close to each other the
                 labels may overlap.
                 \sa pointLabelsVisible, pointLabelsFont, pointLabelsColor
             */
             /*!
                 \qmlproperty string XYSeries::pointLabelsFormat
                 The \a format used for showing labels with series points.
                 \sa pointLabelsFormat, pointLabelsVisible, pointLabelsFont, pointLabelsColor
             */
             /*!
                 \fn void QXYSeries::pointLabelsFormatChanged(const QString &format)
                 Signal is emitted when the \a format of data point labels is changed.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsFormatChanged(string format)
                 Signal is emitted when the \a format of data point labels is changed.
             */
             /*!
                 \property QXYSeries::pointLabelsVisible
                 Defines the visibility for data point labels. False by default.
                 \sa pointLabelsFormat, pointLabelsClipping
             */
             /*!
                 \qmlproperty bool XYSeries::pointLabelsVisible
                 Defines the visibility for data point labels.
                 \sa pointLabelsFormat, pointLabelsClipping
             */
             /*!
                 \fn void QXYSeries::pointLabelsVisibilityChanged(bool visible)
                 The visibility of the data point labels is changed to \a visible.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsVisibilityChanged(bool visible)
                 The visibility of the data point labels is changed to \a visible.
             */
             /*!
                 \property QXYSeries::pointLabelsFont
                 Defines the font used for data point labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \qmlproperty font XYSeries::pointLabelsFont
                 Defines the font used for data point labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QXYSeries::pointLabelsFontChanged(const QFont &font);
                 The font used for data point labels is changed to \a font.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsFontChanged(Font font)
                 The font used for data point labels is changed to \a font.
             */
             /*!
                 \property QXYSeries::pointLabelsColor
                 Defines the color used for data point labels. By default, the color is the color of the brush
                 defined in theme for labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \qmlproperty font XYSeries::pointLabelsColor
                 Defines the color used for data point labels. By default, the color is the color of the brush
                 defined in theme for labels.
                 \sa pointLabelsFormat
             */
             /*!
                 \fn void QXYSeries::pointLabelsColorChanged(const QColor &color);
                 The color used for data point labels is changed to \a color.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsColorChanged(Color color)
                 The color used for data point labels is changed to \a color.
             */
             /*!
                 \property QXYSeries::pointLabelsClipping
                 Defines the clipping for data point labels. True by default. The labels on the edge of the plot
                 area are cut when clipping is enabled.
                 \sa pointLabelsVisible
             */
             /*!
                 \qmlproperty bool XYSeries::pointLabelsClipping
                 Defines the clipping for data point labels. True by default. The labels on the edge of the plot
                 area are cut when clipping is enabled.
                 \sa pointLabelsVisible
             */
             /*!
-                \fn void QXYSeries::pointLabelsClippintChanged(bool clipping)
+                \fn void QXYSeries::pointLabelsClippingChanged(bool clipping)
                 The clipping of the data point labels is changed to \a clipping.
             */
             /*!
                 \qmlsignal XYSeries::onPointLabelsClippingChanged(bool clipping)
                 The clipping of the data point labels is changed to \a clipping.
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart. The \a point is the point
                 where the press was triggered.
                 \sa pressed, released, doubleClicked
             */
             /*!
                 \qmlsignal XYSeries::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on chart. The \a point is the point where the
                 press was triggered. 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
                 \sa onPressed, onReleased, onDoubleClicked
             */
             /*!
                 \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::pressed(const QPointF& point)
                 \brief Signal is emitted when user presses the \a point on chart.
                 \sa clicked, released, doubleClicked
             */
             /*!
                 \qmlsignal XYSeries::onPressed(QPointF point)
                 Signal is emitted when user presses the \a point on chart. For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onPressed: console.log("onPressed: " + point.x + ", " + point.y);
                 }
                 \endcode
                 \sa onClicked, onReleased, onDoubleClicked
             */
             /*!
                 \fn void QXYSeries::released(const QPointF& point)
                 \brief Signal is emitted when user releases a press that was triggered on a \a point on chart.
                 \sa pressed, clicked, doubleClicked
             */
             /*!
                 \qmlsignal XYSeries::onReleased(QPointF point)
                 Signal is emitted when user releases a press that was triggered on a \a point on chart.
                 For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onReleased: console.log("onReleased: " + point.x + ", " + point.y);
                 }
                 \endcode
                 \sa onPressed, onClicked, onDoubleClicked
             */
             /*!
                 \fn void QXYSeries::doubleClicked(const QPointF& point)
                 \brief Signal is emitted when user doubleclicks the \a point on chart. The \a point is the
                 point where the first press was triggered.
                 \sa pressed, released, clicked
             */
             /*!
                 \qmlsignal XYSeries::onDoubleClicked(QPointF point)
                 Signal is emitted when user doubleclicks the \a point on chart. The \a point is the point where
                 the first press was triggered. For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onDoubleClicked: console.log("onDoubleClicked: " + point.x + ", " + point.y);
                 }
                 \endcode
                 \sa onPressed, onReleased, onClicked
             */
             /*!
                 \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()
                 Signal is emitted when all points have been replaced with other points.
             */
             /*!
                 \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::pointsRemoved(int index, int count)
                 Signal is emitted when a \a count of points has been removed starting at \a index.
                 \sa removePoints(), clear()
             */
             /*!
                 \qmlsignal XYSeries::onPointsRemoved(int index, int count)
                 Signal is emitted when a \a count of points has been removed starting at \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 QXYSeries::penChanged(const QPen &pen)
+                \brief Signal is emitted when the line pen has changed to \a pen.
+            */
+            /*!
                 \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::remove(int index)
                 Removes a point from the series at \a index.
             */
             /*!
                 \qmlmethod XYSeries::removePoints(int index, int count)
                 Removes \a count points from the series starting at \a index.
             */
             /*!
                 \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 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 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);
             }
             /*!
               Replaces the point at \a index with data point (\a newX, \a newY).
               \sa pointReplaced()
             */
             void QXYSeries::replace(int index, qreal newX, qreal newY)
             {
                 replace(index, QPointF(newX, newY));
             }
             /*!
               Replaces the point at \a index with \a newPoint.
               \sa pointReplaced()
             */
             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. However, note that using the overload that takes
-              \c{QVector<QPointF>} as parameter is slightly faster than using this overload.
+              \c{QVector<QPointF>} as parameter is faster than using this overload.
               \sa pointsReplaced()
             */
             void QXYSeries::replace(QList<QPointF> points)
             {
                 replace(points.toVector());
             }
             /*!
               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 pointsReplaced()
             */
             void QXYSeries::replace(QVector<QPointF> points)
             {
                 Q_D(QXYSeries);
                 d->m_points = points;
                 emit pointsReplaced();
             }
             /*!
               Removes the point (\a x, \a y) from the series.
               \sa pointRemoved()
             */
             void QXYSeries::remove(qreal x, qreal y)
             {
                 remove(QPointF(x, y));
             }
             /*!
               Removes the \a point from the series.
               \sa pointRemoved()
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if (index == -1)
                     return;
                 remove(index);
             }
             /*!
               Removes the point at \a index from the series.
               \sa pointRemoved()
             */
             void QXYSeries::remove(int index)
             {
                 Q_D(QXYSeries);
                 d->m_points.remove(index);
                 emit pointRemoved(index);
             }
             /*!
               Removes \a count number of points from the series starting at \a index.
               \sa pointsRemoved()
             */
             void QXYSeries::removePoints(int index, int count)
             {
                 // This function doesn't overload remove as there is chance for it to get mixed up with
                 // remove(qreal, qreal) overload in some implicit casting cases.
                 Q_D(QXYSeries);
                 if (count > 0) {
                     d->m_points.remove(index, count);
                     emit pointsRemoved(index, count);
                 }
             }
             /*!
                Inserts a \a point in the series at \a index position.
               \sa pointAdded()
             */
             void QXYSeries::insert(int index, const QPointF &point)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(point)) {
                     index = qMax(0, qMin(index, d->m_points.size()));
                     d->m_points.insert(index, point);
                     emit pointAdded(index);
                 }
             }
             /*!
               Removes all points from the series.
               \sa pointsRemoved()
             */
             void QXYSeries::clear()
             {
                 Q_D(QXYSeries);
                 removePoints(0, d->m_points.size());
             }
             /*!
-                Returns list of points in the series.
+                Returns the points in the series as a list.
+                Use QXYSeries::pointsVector() for better performance.
             */
             QList<QPointF> QXYSeries::points() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.toList();
             }
             /*!
+                Returns the points in the series as a vector.
+                This is more efficient that calling QXYSeries::points();
+            */
+            QVector<QPointF> QXYSeries::pointsVector() const
+            {
+                Q_D(const QXYSeries);
+                return d->m_points;
+            }
+            /*!
                 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());
+                    emit penChanged(pen);
                 }
             }
             QPen QXYSeries::pen() const
             {
                 Q_D(const QXYSeries);
                 if (d->m_pen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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);
                 if (d->m_brush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     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;
             }
             void QXYSeries::setPointLabelsFormat(const QString &format)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsFormat != format) {
                     d->m_pointLabelsFormat = format;
                     emit pointLabelsFormatChanged(format);
                 }
             }
             QString QXYSeries::pointLabelsFormat() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointLabelsFormat;
             }
             void QXYSeries::setPointLabelsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsVisible != visible) {
                     d->m_pointLabelsVisible = visible;
                     emit pointLabelsVisibilityChanged(visible);
                 }
             }
             bool QXYSeries::pointLabelsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointLabelsVisible;
             }
             void QXYSeries::setPointLabelsFont(const QFont &font)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsFont != font) {
                     d->m_pointLabelsFont = font;
                     emit pointLabelsFontChanged(font);
                 }
             }
             QFont QXYSeries::pointLabelsFont() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointLabelsFont;
             }
             void QXYSeries::setPointLabelsColor(const QColor &color)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsColor != color) {
                     d->m_pointLabelsColor = color;
                     emit pointLabelsColorChanged(color);
                 }
             }
             QColor QXYSeries::pointLabelsColor() const
             {
                 Q_D(const QXYSeries);
                 if (d->m_pointLabelsColor == QChartPrivate::defaultPen().color())
                     return QPen().color();
                 else
                     return d->m_pointLabelsColor;
             }
             void QXYSeries::setPointLabelsClipping(bool enabled)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointLabelsClipping != enabled) {
                     d->m_pointLabelsClipping = enabled;
                     emit pointLabelsClippingChanged(enabled);
                 }
             }
             bool QXYSeries::pointLabelsClipping() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointLabelsClipping;
             }
             /*!
                 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_pen(QChartPrivate::defaultPen()),
                   m_brush(QChartPrivate::defaultBrush()),
                   m_pointsVisible(false),
                   m_pointLabelsFormat(QLatin1String("@xPoint, @yPoint")),
                   m_pointLabelsVisible(false),
                   m_pointLabelsFont(QChartPrivate::defaultFont()),
                   m_pointLabelsColor(QChartPrivate::defaultPen().color()),
                   m_pointLabelsClipping(true)
             {
             }
             void QXYSeriesPrivate::initializeDomain()
             {
                 qreal minX(0);
                 qreal minY(0);
                 qreal maxX(1);
                 qreal maxY(1);
                 Q_Q(QXYSeries);
-                const QList<QPointF>& points = q->points();
+                const QVector<QPointF> &points = q->pointsVector();
                 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 new QValueAxis;
             }
             void QXYSeriesPrivate::initializeAnimations(QtCharts::QChart::AnimationOptions options,
                                                         int duration, QEasingCurve &curve)
             {
                 XYChart *item = static_cast<XYChart *>(m_item.data());
                 Q_ASSERT(item);
                 if (item->animation())
                     item->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
                     item->setAnimation(new XYAnimation(item, duration, curve));
                 else
                     item->setAnimation(0);
                 QAbstractSeriesPrivate::initializeAnimations(options, duration, curve);
             }
             void QXYSeriesPrivate::drawSeriesPointLabels(QPainter *painter, const QVector<QPointF> &points,
                                                          const int offset)
             {
                 static const QString xPointTag(QLatin1String("@xPoint"));
                 static const QString yPointTag(QLatin1String("@yPoint"));
                 const int labelOffset = offset + 2;
                 painter->setFont(m_pointLabelsFont);
                 painter->setPen(QPen(m_pointLabelsColor));
                 QFontMetrics fm(painter->font());
                 // m_points is used for the label here as it has the series point information
                 // points variable passed is used for positioning because it has the coordinates
                 for (int i(0); i < m_points.size(); i++) {
                     QString pointLabel = m_pointLabelsFormat;
                     pointLabel.replace(xPointTag, presenter()->numberToString(m_points.at(i).x()));
                     pointLabel.replace(yPointTag, presenter()->numberToString(m_points.at(i).y()));
                     // Position text in relation to the point
                     int pointLabelWidth = fm.width(pointLabel);
                     QPointF position(points.at(i));
                     if (!reverseXAxis())
                         position.setX(position.x() - pointLabelWidth / 2);
                     else
                         position.setX(domain()->size().width() - position.x() - pointLabelWidth / 2);
                     if (!reverseYAxis())
                         position.setY(position.y() - labelOffset);
                     else
                         position.setY(domain()->size().height() - position.y() - labelOffset);
                     painter->drawText(position, pointLabel);
                 }
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/xychart/qxyseries.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #ifndef QXYSERIES_H
             #define QXYSERIES_H
             #include <QtCharts/QChartGlobal>
             #include <QtCharts/QAbstractSeries>
             #include <QtGui/QPen>
             #include <QtGui/QBrush>
             QT_BEGIN_NAMESPACE
             class QModelIndex;
             QT_END_NAMESPACE
             QT_CHARTS_BEGIN_NAMESPACE
             class QXYSeriesPrivate;
             class QXYModelMapper;
             class QT_CHARTS_EXPORT QXYSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(bool pointsVisible READ pointsVisible WRITE setPointsVisible)
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
                 Q_PROPERTY(QString pointLabelsFormat READ pointLabelsFormat WRITE setPointLabelsFormat NOTIFY pointLabelsFormatChanged)
                 Q_PROPERTY(bool pointLabelsVisible READ pointLabelsVisible WRITE setPointLabelsVisible NOTIFY pointLabelsVisibilityChanged)
                 Q_PROPERTY(QFont pointLabelsFont READ pointLabelsFont WRITE setPointLabelsFont NOTIFY pointLabelsFontChanged)
                 Q_PROPERTY(QColor pointLabelsColor READ pointLabelsColor WRITE setPointLabelsColor NOTIFY pointLabelsColorChanged)
                 Q_PROPERTY(bool pointLabelsClipping READ pointLabelsClipping WRITE setPointLabelsClipping NOTIFY pointLabelsClippingChanged)
             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 removePoints(int index, int count);
                 void insert(int index, const QPointF &point);
                 void clear();
                 int count() const;
                 QList<QPointF> points() const;
+                QVector<QPointF> pointsVector() 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 setPointLabelsFormat(const QString &format);
                 QString pointLabelsFormat() const;
                 void setPointLabelsVisible(bool visible = true);
                 bool pointLabelsVisible() const;
                 void setPointLabelsFont(const QFont &font);
                 QFont pointLabelsFont() const;
                 void setPointLabelsColor(const QColor &color);
                 QColor pointLabelsColor() const;
                 void setPointLabelsClipping(bool enabled = true);
                 bool pointLabelsClipping() const;
                 void replace(QList<QPointF> points);
                 void replace(QVector<QPointF> points);
             Q_SIGNALS:
                 void clicked(const QPointF &point);
                 void hovered(const QPointF &point, bool state);
                 void pressed(const QPointF &point);
                 void released(const QPointF &point);
                 void doubleClicked(const QPointF &point);
                 void pointReplaced(int index);
                 void pointRemoved(int index);
                 void pointAdded(int index);
                 void colorChanged(QColor color);
                 void pointsReplaced();
                 void pointLabelsFormatChanged(const QString &format);
                 void pointLabelsVisibilityChanged(bool visible);
                 void pointLabelsFontChanged(const QFont &font);
                 void pointLabelsColorChanged(const QColor &color);
                 void pointLabelsClippingChanged(bool clipping);
                 void pointsRemoved(int index, int count);
+                void penChanged(const QPen &pen);
             private:
                 Q_DECLARE_PRIVATE(QXYSeries)
                 Q_DISABLE_COPY(QXYSeries)
                 friend class QXYLegendMarkerPrivate;
                 friend class XYLegendMarker;
                 friend class XYChart;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QXYSERIES_H

src/charts/xychart/xychart.cpp +73 -46

             /****************************************************************************
              **
              ** Copyright (C) 2015 The Qt Company Ltd
              ** All rights reserved.
              ** For any questions to The Qt Company, please use contact form at http://qt.io
              **
              ** This file is part of the Qt Charts module.
              **
              ** Licensees holding valid commercial license for Qt may use this file in
              ** accordance with the Qt License Agreement provided with the Software
              ** or, alternatively, in accordance with the terms contained in a written
              ** agreement between you and The Qt Company.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.io
              **
              ****************************************************************************/
             #include <private/xychart_p.h>
             #include <QtCharts/QXYSeries>
             #include <private/qxyseries_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/abstractdomain_p.h>
+            #include <private/chartdataset_p.h>
+            #include <private/glxyseriesdata_p.h>
             #include <QtCharts/QXYModelMapper>
             #include <private/qabstractaxis_p.h>
             #include <QtGui/QPainter>
             #include <QtCore/QAbstractItemModel>
             QT_CHARTS_BEGIN_NAMESPACE
             XYChart::XYChart(QXYSeries *series, QGraphicsItem *item):
                   ChartItem(series->d_func(),item),
                   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(series, SIGNAL(pointsRemoved(int, int)), this, SLOT(handlePointsRemoved(int, int)));
                 QObject::connect(this, SIGNAL(clicked(QPointF)), series, SIGNAL(clicked(QPointF)));
                 QObject::connect(this, SIGNAL(hovered(QPointF,bool)), series, SIGNAL(hovered(QPointF,bool)));
                 QObject::connect(this, SIGNAL(pressed(QPointF)), series, SIGNAL(pressed(QPointF)));
                 QObject::connect(this, SIGNAL(released(QPointF)), series, SIGNAL(released(QPointF)));
                 QObject::connect(this, SIGNAL(doubleClicked(QPointF)), series, SIGNAL(doubleClicked(QPointF)));
             }
             void XYChart::setGeometryPoints(const QVector<QPointF> &points)
             {
                 m_points = points;
             }
             void XYChart::setAnimation(XYAnimation *animation)
             {
                 m_animation = animation;
             }
             void XYChart::setDirty(bool dirty)
             {
                 m_dirty = dirty;
             }
             // Returns a vector with same size as geometryPoints vector, indicating
             // the off grid status of points.
             QVector<bool> XYChart::offGridStatusVector()
             {
                 qreal minX = domain()->minX();
                 qreal maxX = domain()->maxX();
                 qreal minY = domain()->minY();
                 qreal maxY = domain()->maxY();
                 QVector<bool> returnVector;
                 returnVector.resize(m_points.size());
                 // During remove animation series may have different number of points,
                 // so ensure we don't go over the index. No need to check for zero points, this
                 // will not be called in such a situation.
                 const int seriesLastIndex = m_series->count() - 1;
                 for (int i = 0; i < m_points.size(); i++) {
                     const QPointF &seriesPoint = m_series->at(qMin(seriesLastIndex, i));
                     if (seriesPoint.x() < minX
                         || seriesPoint.x() > maxX
                         || seriesPoint.y() < minY
                         || seriesPoint.y() > maxY) {
                         returnVector[i] = true;
                     } else {
                         returnVector[i] = false;
                     }
                 }
                 return returnVector;
             }
             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();
                 }
             }
+            void XYChart::updateGlChart()
+            {
+                presenter()->ensureGLWidget();
+                dataSet()->glXYSeriesDataManager()->setPoints(m_series, domain());
+                updateGeometry();
+            }
             //handlers
             void XYChart::handlePointAdded(int index)
             {
                 Q_ASSERT(index < m_series->count());
                 Q_ASSERT(index >= 0);
-                QVector<QPointF> points;
+                if (m_series->useOpenGL()) {
+                    updateGlChart();
-                if (m_dirty || m_points.isEmpty()) {
-                    points = domain()->calculateGeometryPoints(m_series->points());
                 } else {
-                    points = m_points;
+                    QVector<QPointF> points;
-                    QPointF point = domain()->calculateGeometryPoint(m_series->points()[index], m_validData);
+                    if (m_dirty || m_points.isEmpty()) {
-                    if (!m_validData)
+                        points = domain()->calculateGeometryPoints(m_series->pointsVector());
-                        m_points.clear();
+                    } else {
-                    else
+                        points = m_points;
-                        points.insert(index, point);
+                        QPointF point = domain()->calculateGeometryPoint(m_series->pointsVector().at(index),
+                                                                         m_validData);
+                        if (!m_validData)
+                            m_points.clear();
+                        else
+                            points.insert(index, point);
+                    }
+                    updateChart(m_points, points, index);
                 }
-                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_series->useOpenGL()) {
+                    updateGlChart();
-                if (m_dirty || m_points.isEmpty()) {
-                    points = domain()->calculateGeometryPoints(m_series->points());
                 } else {
-                    points = m_points;
+                    QVector<QPointF> points;
-                    points.remove(index);
+                    if (m_dirty || m_points.isEmpty()) {
+                        points = domain()->calculateGeometryPoints(m_series->pointsVector());
+                    } else {
+                        points = m_points;
+                        points.remove(index);
+                    }
+                    updateChart(m_points, points, index);
                 }
-                updateChart(m_points, points, index);
             }
             void XYChart::handlePointsRemoved(int index, int count)
             {
                 Q_ASSERT(index <= m_series->count());
                 Q_ASSERT(index >= 0);
-                QVector<QPointF> points;
+                if (m_series->useOpenGL()) {
+                    updateGlChart();
-                if (m_dirty || m_points.isEmpty()) {
-                    points = domain()->calculateGeometryPoints(m_series->points());
                 } else {
-                    points = m_points;
+                    QVector<QPointF> points;
-                    points.remove(index, count);
+                    if (m_dirty || m_points.isEmpty()) {
+                        points = domain()->calculateGeometryPoints(m_series->pointsVector());
+                    } else {
+                        points = m_points;
+                        points.remove(index, count);
+                    }
+                    updateChart(m_points, points, 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_series->useOpenGL()) {
+                    updateGlChart();
-                if (m_dirty || m_points.isEmpty()) {
-                    points = domain()->calculateGeometryPoints(m_series->points());
                 } else {
-                    QPointF point = domain()->calculateGeometryPoint(m_series->points()[index], m_validData);
+                    QVector<QPointF> points;
-                    if (!m_validData)
+                    if (m_dirty || m_points.isEmpty()) {
-                        m_points.clear();
+                        points = domain()->calculateGeometryPoints(m_series->pointsVector());
-                    points = m_points;
+                    } else {
-                    if (m_validData)
+                        QPointF point = domain()->calculateGeometryPoint(m_series->pointsVector().at(index),
-                        points.replace(index, point);
+                                                                         m_validData);
+                        if (!m_validData)
+                            m_points.clear();
+                        points = m_points;
+                        if (m_validData)
+                            points.replace(index, point);
+                    }
+                    updateChart(m_points, points, index);
                 }
-                updateChart(m_points, points, index);
             }
             void XYChart::handlePointsReplaced()
             {
-                // All the points were replaced -> recalculate
+                if (m_series->useOpenGL()) {
-                QVector<QPointF> points =  domain()->calculateGeometryPoints(m_series->points());
+                    updateGlChart();
-                updateChart(m_points, points, -1);
+                } else {
+                    // All the points were replaced -> recalculate
+                    QVector<QPointF> points = domain()->calculateGeometryPoints(m_series->pointsVector());
+                    updateChart(m_points, points, -1);
+                }
             }
             void XYChart::handleDomainUpdated()
             {
-                if (isEmpty()) return;
+                if (m_series->useOpenGL()) {
-                QVector<QPointF> points =  domain()->calculateGeometryPoints(m_series->points());
+                    updateGlChart();
-                updateChart(m_points, points);
+                } else {
+                    if (isEmpty()) return;
+                    QVector<QPointF> points = domain()->calculateGeometryPoints(m_series->pointsVector());
+                    updateChart(m_points, points);
+                }
             }
             bool XYChart::isEmpty()
             {
                 return domain()->isEmpty() || m_series->points().isEmpty();
             }
             #include "moc_xychart_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/xychart/xychart.pri +4 -2

             #INCLUDEPATH += $$PWD
             #DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/xychart.cpp \
                 $$PWD/qxyseries.cpp \
                 $$PWD/qxymodelmapper.cpp \
                 $$PWD/qvxymodelmapper.cpp \
-                $$PWD/qhxymodelmapper.cpp
+                $$PWD/qhxymodelmapper.cpp  \
+                $$PWD/glxyseriesdata.cpp
             PRIVATE_HEADERS += \
                 $$PWD/xychart_p.h \
                 $$PWD/qxyseries_p.h \
-                $$PWD/qxymodelmapper_p.h
+                $$PWD/qxymodelmapper_p.h \
+                $$PWD/glxyseriesdata_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qxyseries.h \
                 $$PWD/qxymodelmapper.h \
                 $$PWD/qvxymodelmapper.h \
                 $$PWD/qhxymodelmapper.h

src/charts/xychart/xychart_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt 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 XYCHART_H
             #define XYCHART_H
             #include <QtCharts/QChartGlobal>
             #include <private/chartitem_p.h>
             #include <private/xyanimation_p.h>
             #include <QtCharts/QValueAxis>
             #include <QtGui/QPen>
             QT_CHARTS_BEGIN_NAMESPACE
             class ChartPresenter;
             class QXYSeries;
             class XYChart :  public ChartItem
             {
                 Q_OBJECT
             public:
                 explicit XYChart(QXYSeries *series,QGraphicsItem *item = 0);
                 ~XYChart() {}
                 void setGeometryPoints(const QVector<QPointF> &points);
                 QVector<QPointF> geometryPoints() const { return m_points; }
                 void setAnimation(XYAnimation *animation);
                 ChartAnimation *animation() const { return m_animation; }
                 virtual void updateGeometry() = 0;
                 bool isDirty() const { return m_dirty; }
                 void setDirty(bool dirty);
                 void getSeriesRanges(qreal &minX, qreal &maxX, qreal &minY, qreal &maxY);
                 QVector<bool> offGridStatusVector();
             public Q_SLOTS:
                 void handlePointAdded(int index);
                 void handlePointRemoved(int index);
                 void handlePointsRemoved(int index, int count);
                 void handlePointReplaced(int index);
                 void handlePointsReplaced();
                 void handleDomainUpdated();
             Q_SIGNALS:
                 void clicked(const QPointF &point);
                 void hovered(const QPointF &point, bool state);
                 void pressed(const QPointF &point);
                 void released(const QPointF &point);
                 void doubleClicked(const QPointF &point);
             protected:
                 virtual void updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index = -1);
+                virtual void updateGlChart();
             private:
                 inline bool isEmpty();
             protected:
                 QXYSeries *m_series;
                 QVector<QPointF> m_points;
                 XYAnimation *m_animation;
                 bool m_dirty;
                 friend class AreaChartItem;
             };
             QT_CHARTS_END_NAMESPACE
             #endif

src/chartsqml2/chartsqml2.pro +6 -2

             TARGET = qtchartsqml2
             QT += qml quick
             QT += charts charts-private
             TARGETPATH = QtCharts
             IMPORT_VERSION = $$MODULE_VERSION
             # Only build qml plugin static if Qt itself is also built static
             !contains(QT_CONFIG, static): CONFIG -= static staticlib
             include($$PWD/designer/designer.pri)
             INCLUDEPATH += ../../include \
                            ../../include/QtCharts \
                            ../charts \
                            ../charts/animations \
                            ../charts/axis \
                            ../charts/domain
             SOURCES += \
                 chartsqml2_plugin.cpp \
                 declarativechart.cpp \
                 declarativexypoint.cpp \
                 declarativexyseries.cpp \
                 declarativelineseries.cpp \
                 declarativesplineseries.cpp \
                 declarativeareaseries.cpp \
                 declarativescatterseries.cpp \
                 declarativepieseries.cpp \
                 declarativebarseries.cpp \
                 declarativecategoryaxis.cpp \
                 declarativemargins.cpp \
                 declarativeaxes.cpp \
                 declarativepolarchart.cpp \
-                declarativeboxplotseries.cpp
+                declarativeboxplotseries.cpp \
+                declarativechartnode.cpp \
+                declarativerendernode.cpp
             HEADERS += \
                 declarativechart.h \
                 declarativexypoint.h \
                 declarativexyseries.h \
                 declarativelineseries.h \
                 declarativesplineseries.h \
                 declarativeareaseries.h \
                 declarativescatterseries.h \
                 declarativepieseries.h \
                 declarativebarseries.h \
                 declarativecategoryaxis.h \
                 declarativemargins.h \
                 declarativeaxes.h \
                 declarativepolarchart.h \
-                declarativeboxplotseries.h
+                declarativeboxplotseries.h \
+                declarativechartnode.h \
+                declarativerendernode.h
             OTHER_FILES = qmldir
             CONFIG += no_cxx_module
             load(qml_plugin)
             win32 {
                 CONFIG += skip_target_version_ext
                 VERSION = $$MODULE_VERSION
                 QMAKE_TARGET_PRODUCT = "Qt Charts (Qt $$QT_VERSION)"
                 QMAKE_TARGET_DESCRIPTION = "Charts QML plugin for Qt."
             }
             # Copy qmldir to DESTDIR so we can use the plugin directly from there in our examples
             # without having to do 'make install'.
             !android:!ios {
                 copy_qmldir.target = $$DESTDIR/qmldir
                 copy_qmldir.depends = $$_PRO_FILE_PWD_/qmldir
                 copy_qmldir.commands = $(COPY_FILE) \"$$replace(copy_qmldir.depends, /, $$QMAKE_DIR_SEP)\" \"$$replace(copy_qmldir.target, /, $$QMAKE_DIR_SEP)\"
                 QMAKE_EXTRA_TARGETS += copy_qmldir
                 PRE_TARGETDEPS += $$copy_qmldir.target
             }
             QML_FILES += \
                 $$PWD/plugins.qmltypes

src/chartsqml2/declarativechart.cpp +99 -53

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include "declarativechart.h"
             #include <QtGui/QPainter>
             #include "declarativelineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeboxplotseries.h"
             #include "declarativescatterseries.h"
+            #include "declarativechartnode.h"
+            #include "declarativerendernode.h"
             #include <QtCharts/QBarCategoryAxis>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QLogValueAxis>
             #include <QtCharts/QCategoryAxis>
             #include <private/qabstractseries_p.h>
             #include "declarativemargins.h"
             #include <private/chartdataset_p.h>
             #include "declarativeaxes.h"
             #include <private/qchart_p.h>
+            #include <private/chartpresenter_p.h>
             #include <QtCharts/QPolarChart>
             #ifndef QT_ON_ARM
                 #include <QtCharts/QDateTimeAxis>
             #endif
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             #include <QtWidgets/QGraphicsSceneHoverEvent>
             #include <QtWidgets/QApplication>
             #include <QtCore/QTimer>
             #include <QtCore/QThread>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \qmltype ChartView
                 \instantiates DeclarativeChart
                 \inqmlmodule QtCharts
                 \brief Chart element.
                 ChartView element is the parent that is responsible for showing different chart series types.
                 The following QML shows how to create a simple chart with one pie series:
                 \snippet qmlpiechart/qml/qmlpiechart/main.qml 1
                 \snippet qmlpiechart/qml/qmlpiechart/main.qml 2
                 \snippet qmlpiechart/qml/qmlpiechart/main.qml 3
                 \beginfloatleft
                 \image examples_qmlpiechart.png
                 \endfloat
                 \clearfloat
             */
             /*!
               \qmlproperty Theme ChartView::theme
               Theme defines the visual appearance of the chart, including for example colors, fonts, line
               widths and chart background.
             */
             /*!
               \qmlproperty Animation ChartView::animationOptions
               Animation configuration of the chart. One of ChartView.NoAnimation, ChartView.GridAxisAnimations,
               ChartView.SeriesAnimations or ChartView.AllAnimations.
             */
             /*!
              \qmlproperty int ChartView::animationDuration
              The duration of the animation for the chart.
              */
             /*!
              \qmlproperty easing ChartView::animationEasingCurve
              The easing curve of the animation for the chart.
+            */
             /*!
               \qmlproperty Font ChartView::titleFont
               The title font of the chart.
               See the Qt documentation for more details of Font.
             */
             /*!
               \qmlproperty string ChartView::title
               The title of the chart, shown on top of the chart.
               \sa ChartView::titleColor
             */
             /*!
               \qmlproperty color ChartView::titleColor
               The color of the title text.
             */
             /*!
               \qmlproperty Legend ChartView::legend
               The legend of the chart. Legend lists all the series, pie slices and bar sets added on the chart.
             */
             /*!
               \qmlproperty int ChartView::count
               The count of series added to the chart.
             */
             /*!
               \qmlproperty color ChartView::backgroundColor
               The color of the chart's background. By default background color is defined by chart theme.
               \sa ChartView::theme
             */
             /*!
               \qmlproperty real ChartView::backgroundRoundness
               The diameter of the rounding circle at the corners of the chart background.
             */
             /*!
               \qmlproperty color ChartView::plotAreaColor
               The color of the background of the chart's plot area. By default plot area background uses chart's
               background color.
               \sa ChartView::backgroundColor
             */
             /*!
               \qmlproperty list<AbstractAxis> ChartView::axes
               The axes of the ChartView.
             */
             /*!
               \qmlproperty bool ChartView::dropShadowEnabled
               The chart's border drop shadow. Set to true to enable drop shadow.
             */
             /*!
               \qmlproperty rect ChartView::plotArea
               The area on the ChartView that is used for drawing series. This is the ChartView rect without the
               margins.
               \sa ChartView::margins
             */
             /*!
               \qmlproperty Margins ChartView::margins
               The minimum margins allowed between the outer bounds and the plotArea of the ChartView. Margins
               area of ChartView is used for drawing title, axes and legend.
             */
             /*!
               \qmlproperty bool ChartView::localizeNumbers
               \since QtCharts 2.0
               When \c{true}, all generated numbers appearing in various series and axis labels will be
               localized using the default QLocale of the application, which defaults to the system locale.
               When \c{false}, the "C" locale is always used.
               Defaults to \c{false}.
               \sa locale
             */
             /*!
               \qmlproperty locale ChartView::locale
               \since QtCharts 2.0
               Sets the locale used to format various chart labels when localizeNumbers is \c{true}.
               This also determines the locale used to format DateTimeAxis labels regardless of
               localizeNumbers property.
               Defaults to application default locale at the time the chart is constructed.
               \sa localizeNumbers
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(int index)
               Returns the series with \a index on the chart. This allows you to loop through the series of a chart together with
               the count property of the chart.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(string name)
               Returns the first series on the chart with \a name. If there is no series with that name, returns null.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::createSeries(SeriesType type, string name, AbstractAxis axisX, AbstractAxis axisY)
               Creates a series object of \a type to the chart with name \a name, optional axis \a axisX and
               optional axis \a axisY. For example:
               \code
                 // lineSeries is a LineSeries object that has already been added to the ChartView; re-use it's axes
                 var myAxisX = chartView.axisX(lineSeries);
                 var myAxisY = chartView.axisY(lineSeries);
                 var scatter = chartView.createSeries(ChartView.SeriesTypeScatter, "scatter series", myAxisX, myAxisY);
               \endcode
             */
             /*!
               \qmlmethod ChartView::removeSeries(AbstractSeries series)
               Removes the \a series from the chart. The series object is also destroyed.
             */
             /*!
               \qmlmethod ChartView::removeAllSeries()
               Removes all series from the chart. All the series objects are also destroyed.
             */
             /*!
               \qmlmethod Axis ChartView::axisX(AbstractSeries series)
               The x-axis of the series.
             */
             /*!
               \qmlmethod ChartView::setAxisX(AbstractAxis axis, AbstractSeries series)
               Set the x-axis of the series.
             */
             /*!
               \qmlmethod Axis ChartView::axisY(AbstractSeries series)
               The y-axis of the series.
             */
             /*!
               \qmlmethod ChartView::setAxisY(AbstractAxis axis, AbstractSeries series)
               Set the y-axis of the series.
             */
             /*!
               \qmlmethod ChartView::zoom(real factor)
               Zooms in by \a factor on the center of the chart.
               A factor over 1.0 zooms the view in and factor between 0.0 and 1.0 zooms out.
             */
             /*!
               \qmlmethod ChartView::zoomIn()
               Zooms in the view by a factor of two.
             */
             /*!
               \qmlmethod ChartView::zoomIn(rect rectangle)
               Zooms in the view to a maximum level at which \a rectangle is still fully visible.
               \note This is not supported for polar charts.
             */
             /*!
               \qmlmethod ChartView::zoomOut()
               Zooms out the view by a factor of two.
             */
             /*!
               \qmlmethod ChartView::zoomReset()
               Resets the series domains to what they were before any zoom method was called.
               Note that this will also reset any scrolls and explicit axis range settings done between
               the first zoom operation and calling this method. If no zoom operation has been
               done, this method does nothing.
             */
             /*!
               \qmlmethod ChartView::isZoomed()
               Returns true if any series has a zoomed domain.
             */
             /*!
               \qmlmethod ChartView::scrollLeft(real pixels)
               Scrolls to left by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod ChartView::scrollRight(real pixels)
               Scrolls to right by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod ChartView::scrollUp(real pixels)
               Scrolls up by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod ChartView::scrollDown(real pixels)
               Scrolls down by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod point ChartView::mapToValue(point position, AbstractSeries series)
               Returns the value in the \a series domain that corresponds to the \a position relative to the
               chart.
             */
             /*!
               \qmlmethod point ChartView::mapToPosition(point value, AbstractSeries series)
               Returns the position on the chart that corresponds to the \a value in the \a series domain.
             */
             /*!
               \qmlsignal ChartView::seriesAdded(AbstractSeries series)
               The \a series has been added to the chart.
             */
             /*!
               \qmlsignal ChartView::seriesRemoved(AbstractSeries series)
               The \a series has been removed from the chart. Please note that \a series is no longer a valid
               object after the signal handler has completed.
             */
             DeclarativeChart::DeclarativeChart(QQuickItem *parent)
-                : QQuickPaintedItem(parent)
+                : QQuickItem(parent)
             {
                 initChart(QChart::ChartTypeCartesian);
             }
             DeclarativeChart::DeclarativeChart(QChart::ChartType type, QQuickItem *parent)
-                : QQuickPaintedItem(parent)
+                : QQuickItem(parent)
             {
                 initChart(type);
             }
             void DeclarativeChart::initChart(QChart::ChartType type)
             {
-                m_currentSceneImage = 0;
+                m_sceneImage = 0;
+                m_sceneImageDirty = false;
                 m_guiThreadId = QThread::currentThreadId();
                 m_paintThreadId = 0;
                 m_updatePending = false;
+                setFlag(ItemHasContents, true);
                 if (type == QChart::ChartTypePolar)
                     m_chart = new QPolarChart();
                 else
                     m_chart = new QChart();
+                m_chart->d_ptr->m_presenter->glSetUseWidget(false);
+                m_glXYDataManager = m_chart->d_ptr->m_dataset->glXYSeriesDataManager();
                 m_scene = new QGraphicsScene(this);
                 m_scene->addItem(m_chart);
                 setAntialiasing(QQuickItem::antialiasing());
-                connect(m_scene, SIGNAL(changed(QList<QRectF>)), this, SLOT(sceneChanged(QList<QRectF>)));
+                connect(m_scene, &QGraphicsScene::changed, this, &DeclarativeChart::sceneChanged);
+                connect(this, &DeclarativeChart::needRender, this, &DeclarativeChart::renderScene,
+                        Qt::QueuedConnection);
                 connect(this, SIGNAL(antialiasingChanged(bool)), this, SLOT(handleAntialiasingChanged(bool)));
                 setAcceptedMouseButtons(Qt::AllButtons);
                 setAcceptHoverEvents(true);
                 m_margins = new DeclarativeMargins(this);
                 m_margins->setTop(m_chart->margins().top());
                 m_margins->setLeft(m_chart->margins().left());
                 m_margins->setRight(m_chart->margins().right());
                 m_margins->setBottom(m_chart->margins().bottom());
                 connect(m_margins, SIGNAL(topChanged(int,int,int,int)),
                         this, SLOT(changeMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(bottomChanged(int,int,int,int)),
                         this, SLOT(changeMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(leftChanged(int,int,int,int)),
                         this, SLOT(changeMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(rightChanged(int,int,int,int)),
                         this, SLOT(changeMargins(int,int,int,int)));
                 connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), this, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), this, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 connect(m_chart, &QChart::plotAreaChanged, this, &DeclarativeChart::plotAreaChanged);
             }
             void DeclarativeChart::handleSeriesAdded(QAbstractSeries *series)
             {
                 emit seriesAdded(series);
             }
             void DeclarativeChart::changeMargins(int top, int bottom, int left, int right)
             {
                 m_chart->setMargins(QMargins(left, top, right, bottom));
                 emit marginsChanged();
             }
             DeclarativeChart::~DeclarativeChart()
             {
                 delete m_chart;
-                m_sceneImageLock.lock();
+                delete m_sceneImage;
-                delete m_currentSceneImage;
-                m_currentSceneImage = 0;
-                m_sceneImageLock.unlock();
             }
             void DeclarativeChart::childEvent(QChildEvent *event)
             {
                 if (event->type() == QEvent::ChildAdded) {
                     if (qobject_cast<QAbstractSeries *>(event->child())) {
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(event->child()));
                     }
                 }
             }
             void DeclarativeChart::componentComplete()
             {
                 foreach (QObject *child, children()) {
                     if (qobject_cast<QAbstractSeries *>(child)) {
                         // Add series to the chart
                         QAbstractSeries *series = qobject_cast<QAbstractSeries *>(child);
                         m_chart->addSeries(series);
                         // Connect to axis changed signals (unless this is a pie series)
                         if (!qobject_cast<DeclarativePieSeries *>(series)) {
                             connect(series, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SLOT(handleAxisXTopSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SLOT(handleAxisYRightSet(QAbstractAxis*)));
                         }
                         initializeAxes(series);
                     }
                 }
                 QQuickItem::componentComplete();
             }
             void DeclarativeChart::seriesAxisAttachHelper(QAbstractSeries *series, QAbstractAxis *axis,
                                                           Qt::Orientations orientation,
                                                           Qt::Alignment alignment)
             {
                 if (!series->attachedAxes().contains(axis)) {
                     // Remove & delete old axes that are not attached to any other series
                     foreach (QAbstractAxis* oldAxis, m_chart->axes(orientation, series)) {
                         bool otherAttachments = false;
                         if (oldAxis != axis) {
                             foreach (QAbstractSeries *oldSeries, m_chart->series()) {
                                 if (oldSeries != series && oldSeries->attachedAxes().contains(oldAxis)) {
                                     otherAttachments = true;
                                     break;
                                 }
                             }
                             if (!otherAttachments) {
                                 m_chart->removeAxis(oldAxis);
                                 delete oldAxis;
                             }
                         }
                     }
                     if (!m_chart->axes(orientation).contains(axis))
                         m_chart->addAxis(axis, alignment);
                     series->attachAxis(axis);
                 }
             }
             void DeclarativeChart::handleAxisXSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Horizontal, Qt::AlignBottom);
                 } else {
                     qWarning() << "Trying to set axisX to null.";
                 }
             }
             void DeclarativeChart::handleAxisXTopSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Horizontal, Qt::AlignTop);
                 } else {
                     qWarning() << "Trying to set axisXTop to null.";
                 }
             }
             void DeclarativeChart::handleAxisYSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Vertical, Qt::AlignLeft);
                 } else {
                     qWarning() << "Trying to set axisY to null.";
                 }
             }
             void DeclarativeChart::handleAxisYRightSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Vertical, Qt::AlignRight);
                 } else {
                     qWarning() << "Trying to set axisYRight to null.";
                 }
             }
             void DeclarativeChart::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
             {
                 if (newGeometry.isValid()) {
                     if (newGeometry.width() > 0 && newGeometry.height() > 0) {
                         m_chart->resize(newGeometry.width(), newGeometry.height());
                     }
                 }
                 QQuickItem::geometryChanged(newGeometry, oldGeometry);
             }
-            void DeclarativeChart::sceneChanged(QList<QRectF> region)
+            QSGNode *DeclarativeChart::updatePaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *)
             {
-                Q_UNUSED(region);
+                DeclarativeChartNode *node = static_cast<DeclarativeChartNode *>(oldNode);
-                if (m_guiThreadId == m_paintThreadId) {
+                if (!node) {
-                    // Rendering in gui thread, no need for shenannigans, just update
+                    node =  new DeclarativeChartNode(window());
-                    update();
+                    connect(window(), &QQuickWindow::beforeRendering,
-                } else {
+                            node->glRenderNode(), &DeclarativeRenderNode::render);
-                    // Multi-threaded rendering, need to ensure scene is actually rendered in gui thread
-                    if (!m_updatePending) {
+                const QRectF &bRect = boundingRect();
+                // Update GL data
+                if (m_glXYDataManager->dataMap().size() || m_glXYDataManager->mapDirty()) {
+                    const QRectF &plotArea = m_chart->plotArea();
+                    const QSizeF &chartAreaSize = m_chart->size();
+                    // We can't use chart's plot area directly, as graphicscene has some internal minimum size
+                    const qreal normalizedX = plotArea.x() / chartAreaSize.width();
+                    const qreal normalizedY = plotArea.y() / chartAreaSize.height();
+                    const qreal normalizedWidth = plotArea.width() / chartAreaSize.width();
+                    const qreal normalizedHeight = plotArea.height() / chartAreaSize.height();
+                    QRectF adjustedPlotArea(normalizedX * bRect.width(),
+                                            normalizedY * bRect.height(),
+                                            normalizedWidth * bRect.width(),
+                                            normalizedHeight * bRect.height());
+                    const QSize &adjustedPlotSize = adjustedPlotArea.size().toSize();
+                    if (adjustedPlotSize != node->glRenderNode()->textureSize())
+                        node->glRenderNode()->setTextureSize(adjustedPlotSize);
+                    node->glRenderNode()->setRect(adjustedPlotArea);
+                    node->glRenderNode()->setSeriesData(m_glXYDataManager->mapDirty(),
+                                                        m_glXYDataManager->dataMap());
+                    // Clear dirty flags from original xy data
+                    m_glXYDataManager->clearAllDirty();
+                }
+                // Copy chart (if dirty) to chart node
+                if (m_sceneImageDirty) {
+                    node->createTextureFromImage(*m_sceneImage);
+                    m_sceneImageDirty = false;
+                }
+                node->setRect(bRect);
+                return node;
+            }
+            void DeclarativeChart::sceneChanged(QList<QRectF> region)
+            {
+                const int count = region.size();
+                const qreal limitSize = 0.01;
+                if (count && !m_updatePending) {
+                    qreal totalSize = 0.0;
+                    for (int i = 0; i < count; i++) {
+                        const QRectF &reg = region.at(i);
+                        totalSize += (reg.height() * reg.width());
+                        if (totalSize >= limitSize)
+                            break;
+                    }
+                    // Ignore region updates that change less than small fraction of a pixel, as there is
+                    // little point regenerating the image in these cases. These are typically cases
+                    // where OpenGL series are drawn to otherwise static chart.
+                    if (totalSize >= limitSize) {
                         m_updatePending = true;
                         // Do async render to avoid some unnecessary renders.
-                        QTimer::singleShot(0, this, SLOT(renderScene()));
+                        emit needRender();
+                    } else {
+                        // We do want to call update to trigger possible gl series updates.
+                        update();
                     }
                 }
             }
             void DeclarativeChart::renderScene()
             {
                 m_updatePending = false;
-                m_sceneImageLock.lock();
+                m_sceneImageDirty = true;
-                delete m_currentSceneImage;
+                QSize chartSize = m_chart->size().toSize();
-                m_currentSceneImage = new QImage(m_chart->size().toSize(), QImage::Format_ARGB32);
+                if (!m_sceneImage || chartSize != m_sceneImage->size()) {
-                m_currentSceneImage->fill(Qt::transparent);
+                    delete m_sceneImage;
-                QPainter painter(m_currentSceneImage);
+                    m_sceneImage = new QImage(chartSize, QImage::Format_ARGB32);
-                if (antialiasing())
+                    m_sceneImage->fill(Qt::transparent);
-                    painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform);
-                QRect renderRect(QPoint(0, 0), m_chart->size().toSize());
-                m_scene->render(&painter, renderRect, renderRect);
-                m_sceneImageLock.unlock();
-                update();
-            void DeclarativeChart::paint(QPainter *painter)
-                if (!m_paintThreadId) {
-                    m_paintThreadId = QThread::currentThreadId();
-                    if (m_guiThreadId == m_paintThreadId) {
-                        // No need for scene image in single threaded rendering, so delete
-                        // the one that got made by default before the rendering type was
-                        // detected.
-                        delete m_currentSceneImage;
-                        m_currentSceneImage = 0;
                 }
-                if (m_guiThreadId == m_paintThreadId) {
+                QPainter painter(m_sceneImage);
-                    QRectF renderRect(QPointF(0, 0), m_chart->size());
+                if (antialiasing()) {
-                    m_scene->render(painter, renderRect, renderRect);
+                    painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing
-                } else {
+                                           | QPainter::SmoothPixmapTransform);
-                    m_sceneImageLock.lock();
-                    if (m_currentSceneImage) {
-                        QRect imageRect(QPoint(0, 0), m_currentSceneImage->size());
-                        QRect itemRect(QPoint(0, 0), QSize(width(), height()));
-                        painter->drawImage(itemRect, *m_currentSceneImage, imageRect);
-                    m_sceneImageLock.unlock();
                 }
+                QRect renderRect(QPoint(0, 0), chartSize);
+                m_scene->render(&painter, renderRect, renderRect);
+                update();
             }
             void DeclarativeChart::mousePressEvent(QMouseEvent *event)
             {
                 m_mousePressScenePoint = event->pos();
                 m_mousePressScreenPoint = event->globalPos();
                 m_lastMouseMoveScenePoint = m_mousePressScenePoint;
                 m_lastMouseMoveScreenPoint = m_mousePressScreenPoint;
                 m_mousePressButton = event->button();
                 m_mousePressButtons = event->buttons();
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMousePress);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(m_mousePressScenePoint);
                 mouseEvent.setScreenPos(m_mousePressScreenPoint);
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(m_mousePressButtons);
                 mouseEvent.setButton(m_mousePressButton);
                 mouseEvent.setModifiers(event->modifiers());
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
             }
             void DeclarativeChart::mouseReleaseEvent(QMouseEvent *event)
             {
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseRelease);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(event->pos());
                 mouseEvent.setScreenPos(event->globalPos());
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(event->buttons());
                 mouseEvent.setButton(event->button());
                 mouseEvent.setModifiers(event->modifiers());
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
                 m_mousePressButtons = event->buttons();
                 m_mousePressButton = Qt::NoButton;
             }
             void DeclarativeChart::hoverMoveEvent(QHoverEvent *event)
             {
                 // Convert hover move to mouse move, since we don't seem to get actual mouse move events.
                 // QGraphicsScene generates hover events from mouse move events, so we don't need
                 // to pass hover events there.
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseMove);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(event->pos());
                 // Hover events do not have global pos in them, and the screen position doesn't seem to
                 // matter anyway in this use case, so just pass event pos instead of trying to
                 // calculate the real screen position.
                 mouseEvent.setScreenPos(event->pos());
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(m_mousePressButtons);
                 mouseEvent.setButton(m_mousePressButton);
                 mouseEvent.setModifiers(event->modifiers());
                 m_lastMouseMoveScenePoint = mouseEvent.scenePos();
                 m_lastMouseMoveScreenPoint = mouseEvent.screenPos();
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
             }
             void DeclarativeChart::mouseDoubleClickEvent(QMouseEvent *event)
             {
                 m_mousePressScenePoint = event->pos();
                 m_mousePressScreenPoint = event->globalPos();
                 m_lastMouseMoveScenePoint = m_mousePressScenePoint;
                 m_lastMouseMoveScreenPoint = m_mousePressScreenPoint;
                 m_mousePressButton = event->button();
                 m_mousePressButtons = event->buttons();
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseDoubleClick);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(m_mousePressScenePoint);
                 mouseEvent.setScreenPos(m_mousePressScreenPoint);
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(m_mousePressButtons);
                 mouseEvent.setButton(m_mousePressButton);
                 mouseEvent.setModifiers(event->modifiers());
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
             }
             void DeclarativeChart::handleAntialiasingChanged(bool enable)
             {
                 setAntialiasing(enable);
             }
             void DeclarativeChart::setTheme(DeclarativeChart::Theme theme)
             {
                 QChart::ChartTheme chartTheme = (QChart::ChartTheme) theme;
                 if (chartTheme != m_chart->theme())
                     m_chart->setTheme(chartTheme);
             }
             DeclarativeChart::Theme DeclarativeChart::theme()
             {
                 return (DeclarativeChart::Theme) m_chart->theme();
             }
             void DeclarativeChart::setAnimationOptions(DeclarativeChart::Animation animations)
             {
                 QChart::AnimationOption animationOptions = (QChart::AnimationOption) animations;
                 if (animationOptions != m_chart->animationOptions())
                     m_chart->setAnimationOptions(animationOptions);
             }
             DeclarativeChart::Animation DeclarativeChart::animationOptions()
             {
                 if (m_chart->animationOptions().testFlag(QChart::AllAnimations))
                     return DeclarativeChart::AllAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::GridAxisAnimations))
                     return DeclarativeChart::GridAxisAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::SeriesAnimations))
                     return DeclarativeChart::SeriesAnimations;
                 else
                     return DeclarativeChart::NoAnimation;
             }
             void DeclarativeChart::setAnimationDuration(int msecs)
             {
                 if (msecs != m_chart->animationDuration()) {
                     m_chart->setAnimationDuration(msecs);
                     emit animationDurationChanged(msecs);
                 }
             }
             int DeclarativeChart::animationDuration() const
             {
                 return m_chart->animationDuration();
             }
             void DeclarativeChart::setAnimationEasingCurve(const QEasingCurve &curve)
             {
                 if (curve != m_chart->animationEasingCurve()) {
                     m_chart->setAnimationEasingCurve(curve);
                     emit animationEasingCurveChanged(curve);
                 }
             }
             QEasingCurve DeclarativeChart::animationEasingCurve() const
             {
                 return m_chart->animationEasingCurve();
             }
             void DeclarativeChart::setTitle(QString title)
             {
                 if (title != m_chart->title())
                     m_chart->setTitle(title);
             }
             QString DeclarativeChart::title()
             {
                 return m_chart->title();
             }
             QAbstractAxis *DeclarativeChart::axisX(QAbstractSeries *series)
             {
                 QList<QAbstractAxis *> axes = m_chart->axes(Qt::Horizontal, series);
                 if (axes.count())
                     return axes[0];
                 return 0;
             }
             QAbstractAxis *DeclarativeChart::axisY(QAbstractSeries *series)
             {
                 QList<QAbstractAxis *> axes = m_chart->axes(Qt::Vertical, series);
                 if (axes.count())
                     return axes[0];
                 return 0;
             }
             QLegend *DeclarativeChart::legend()
             {
                 return m_chart->legend();
             }
             void DeclarativeChart::setTitleColor(QColor color)
             {
                 QBrush b = m_chart->titleBrush();
                 if (color != b.color()) {
                     b.setColor(color);
                     m_chart->setTitleBrush(b);
                     emit titleColorChanged(color);
                 }
             }
             QFont DeclarativeChart::titleFont() const
             {
                 return m_chart->titleFont();
             }
             void DeclarativeChart::setTitleFont(const QFont &font)
             {
                 m_chart->setTitleFont(font);
             }
             QColor DeclarativeChart::titleColor()
             {
                 return m_chart->titleBrush().color();
             }
             void DeclarativeChart::setBackgroundColor(QColor color)
             {
                 QBrush b = m_chart->backgroundBrush();
                 if (b.style() != Qt::SolidPattern || color != b.color()) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setBackgroundBrush(b);
                     emit backgroundColorChanged();
                 }
             }
             QColor DeclarativeChart::backgroundColor()
             {
                 return m_chart->backgroundBrush().color();
             }
             void QtCharts::DeclarativeChart::setPlotAreaColor(QColor color)
             {
                 QBrush b = m_chart->plotAreaBackgroundBrush();
                 if (b.style() != Qt::SolidPattern || color != b.color()) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setPlotAreaBackgroundBrush(b);
                     m_chart->setPlotAreaBackgroundVisible(true);
                     emit plotAreaColorChanged();
                 }
             }
             QColor QtCharts::DeclarativeChart::plotAreaColor()
             {
                 return m_chart->plotAreaBackgroundBrush().color();
             }
             void DeclarativeChart::setLocalizeNumbers(bool localize)
             {
                 if (m_chart->localizeNumbers() != localize) {
                     m_chart->setLocalizeNumbers(localize);
                     emit localizeNumbersChanged();
                 }
             }
             bool DeclarativeChart::localizeNumbers() const
             {
                 return m_chart->localizeNumbers();
             }
             void QtCharts::DeclarativeChart::setLocale(const QLocale &locale)
             {
                 if (m_chart->locale() != locale) {
                     m_chart->setLocale(locale);
                     emit localeChanged();
                 }
             }
             QLocale QtCharts::DeclarativeChart::locale() const
             {
                 return m_chart->locale();
             }
             int DeclarativeChart::count()
             {
                 return m_chart->series().count();
             }
             void DeclarativeChart::setDropShadowEnabled(bool enabled)
             {
                 if (enabled != m_chart->isDropShadowEnabled()) {
                     m_chart->setDropShadowEnabled(enabled);
                     dropShadowEnabledChanged(enabled);
                 }
             }
             bool DeclarativeChart::dropShadowEnabled()
             {
                 return m_chart->isDropShadowEnabled();
             }
             qreal DeclarativeChart::backgroundRoundness() const
             {
                 return m_chart->backgroundRoundness();
             }
             void DeclarativeChart::setBackgroundRoundness(qreal diameter)
             {
                 if (m_chart->backgroundRoundness() != diameter) {
                     m_chart->setBackgroundRoundness(diameter);
                     emit backgroundRoundnessChanged(diameter);
                 }
             }
             void DeclarativeChart::zoom(qreal factor)
             {
                 m_chart->zoom(factor);
             }
             void DeclarativeChart::zoomIn()
             {
                 m_chart->zoomIn();
             }
             void DeclarativeChart::zoomIn(const QRectF &rectangle)
             {
                 m_chart->zoomIn(rectangle);
             }
             void DeclarativeChart::zoomOut()
             {
                 m_chart->zoomOut();
             }
             void DeclarativeChart::zoomReset()
             {
                 m_chart->zoomReset();
             }
             bool DeclarativeChart::isZoomed()
             {
                 return m_chart->isZoomed();
             }
             void DeclarativeChart::scrollLeft(qreal pixels)
             {
                 m_chart->scroll(-pixels, 0);
             }
             void DeclarativeChart::scrollRight(qreal pixels)
             {
                 m_chart->scroll(pixels, 0);
             }
             void DeclarativeChart::scrollUp(qreal pixels)
             {
                 m_chart->scroll(0, pixels);
             }
             void DeclarativeChart::scrollDown(qreal pixels)
             {
                 m_chart->scroll(0, -pixels);
             }
             QQmlListProperty<QAbstractAxis> DeclarativeChart::axes()
             {
                 return QQmlListProperty<QAbstractAxis>(this, 0,
                             &DeclarativeChart::axesAppendFunc,
                             &DeclarativeChart::axesCountFunc,
                             &DeclarativeChart::axesAtFunc,
                             &DeclarativeChart::axesClearFunc);
             }
             void DeclarativeChart::axesAppendFunc(QQmlListProperty<QAbstractAxis> *list, QAbstractAxis *element)
             {
                 // Empty implementation
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             int DeclarativeChart::axesCountFunc(QQmlListProperty<QAbstractAxis> *list)
             {
                 if (qobject_cast<DeclarativeChart *>(list->object)) {
                     DeclarativeChart *chart = qobject_cast<DeclarativeChart *>(list->object);
                     return chart->m_chart->axes(Qt::Horizontal | Qt::Vertical).count();
                 }
                 return 0;
             }
             QAbstractAxis *DeclarativeChart::axesAtFunc(QQmlListProperty<QAbstractAxis> *list, int index)
             {
                 if (qobject_cast<DeclarativeChart *>(list->object)) {
                     DeclarativeChart *chart = qobject_cast<DeclarativeChart *>(list->object);
                     QList<QAbstractAxis *> axes = chart->m_chart->axes(Qt::Horizontal | Qt::Vertical, chart->m_chart->series()[0]);
                     return axes.at(index);
                 }
                 return 0;
             }
             void DeclarativeChart::axesClearFunc(QQmlListProperty<QAbstractAxis> *list)
             {
                 // Empty implementation
                 Q_UNUSED(list);
             }
             QAbstractSeries *DeclarativeChart::series(int index)
             {
                 if (index < m_chart->series().count()) {
                     return m_chart->series().at(index);
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::series(QString seriesName)
             {
                 foreach (QAbstractSeries *series, m_chart->series()) {
                     if (series->name() == seriesName)
                         return series;
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::createSeries(int type, QString name, QAbstractAxis *axisX, QAbstractAxis *axisY)
             {
                 QAbstractSeries *series = 0;
                 switch (type) {
                 case DeclarativeChart::SeriesTypeLine:
                     series = new DeclarativeLineSeries();
                     break;
                 case DeclarativeChart::SeriesTypeArea: {
                     DeclarativeAreaSeries *area = new DeclarativeAreaSeries();
                     DeclarativeLineSeries *line = new DeclarativeLineSeries();
                     line->setParent(area);
                     area->setUpperSeries(line);
                     series = area;
                     break;
                 }
                 case DeclarativeChart::SeriesTypeStackedBar:
                     series = new DeclarativeStackedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypePercentBar:
                     series = new DeclarativePercentBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBar:
                     series = new DeclarativeBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalBar:
                     series = new DeclarativeHorizontalBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalPercentBar:
                     series = new DeclarativeHorizontalPercentBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalStackedBar:
                     series = new DeclarativeHorizontalStackedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBoxPlot:
                     series = new DeclarativeBoxPlotSeries();
                     break;
                 case DeclarativeChart::SeriesTypePie:
                     series = new DeclarativePieSeries();
                     break;
                 case DeclarativeChart::SeriesTypeScatter:
                     series = new DeclarativeScatterSeries();
                     break;
                 case DeclarativeChart::SeriesTypeSpline:
                     series = new DeclarativeSplineSeries();
                     break;
                 default:
                     qWarning() << "Illegal series type";
                 }
                 if (series) {
                     // Connect to axis changed signals (unless this is a pie series)
                     if (!qobject_cast<DeclarativePieSeries *>(series)) {
                         connect(series, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                         connect(series, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                         connect(series, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                         connect(series, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SLOT(handleAxisYRightSet(QAbstractAxis*)));
                     }
                     series->setName(name);
                     m_chart->addSeries(series);
                     if (!axisX || !axisY)
                         initializeAxes(series);
                     if (axisX)
                         setAxisX(axisX, series);
                     if (axisY)
                         setAxisY(axisY, series);
                 }
                 return series;
             }
             void DeclarativeChart::removeSeries(QAbstractSeries *series)
             {
                 if (series)
                     m_chart->removeSeries(series);
                 else
                     qWarning("removeSeries: cannot remove null");
             }
             void DeclarativeChart::setAxisX(QAbstractAxis *axis, QAbstractSeries *series)
             {
                 if (axis && series)
                     seriesAxisAttachHelper(series, axis, Qt::Horizontal, Qt::AlignBottom);
             }
             void DeclarativeChart::setAxisY(QAbstractAxis *axis, QAbstractSeries *series)
             {
                 if (axis && series)
                     seriesAxisAttachHelper(series, axis, Qt::Vertical, Qt::AlignLeft);
             }
             QAbstractAxis *DeclarativeChart::defaultAxis(Qt::Orientation orientation, QAbstractSeries *series)
             {
                 if (!series) {
                     qWarning() << "No axis type defined for null series";
                     return 0;
                 }
                 foreach (QAbstractAxis *existingAxis, m_chart->axes(orientation)) {
                     if (existingAxis->type() == series->d_ptr->defaultAxisType(orientation))
                         return existingAxis;
                 }
                 switch (series->d_ptr->defaultAxisType(orientation)) {
                 case QAbstractAxis::AxisTypeValue:
                     return new QValueAxis(this);
                 case QAbstractAxis::AxisTypeBarCategory:
                     return new QBarCategoryAxis(this);
                 case QAbstractAxis::AxisTypeCategory:
                     return new QCategoryAxis(this);
             #ifndef QT_ON_ARM
                 case QAbstractAxis::AxisTypeDateTime:
                     return new QDateTimeAxis(this);
             #endif
                 case QAbstractAxis::AxisTypeLogValue:
                     return new QLogValueAxis(this);
                 default:
                     // assume AxisTypeNoAxis
                     return 0;
                 }
             }
             void DeclarativeChart::initializeAxes(QAbstractSeries *series)
             {
                 if (qobject_cast<DeclarativeLineSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeLineSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeScatterSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeScatterSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeSplineSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeSplineSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeAreaSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeAreaSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeStackedBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeStackedBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativePercentBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativePercentBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeHorizontalBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeHorizontalBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeHorizontalStackedBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeHorizontalStackedBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeHorizontalPercentBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeHorizontalPercentBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeBoxPlotSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeBoxPlotSeries *>(series)->m_axes);
                 // else: do nothing
             }
             void DeclarativeChart::doInitializeAxes(QAbstractSeries *series, DeclarativeAxes *axes)
             {
                 qreal min;
                 qreal max;
                 // Initialize axis X
                 if (axes->axisX()) {
                     axes->emitAxisXChanged();
                 } else if (axes->axisXTop()) {
                     axes->emitAxisXTopChanged();
                 } else {
                     axes->setAxisX(defaultAxis(Qt::Horizontal, series));
                     findMinMaxForSeries(series, Qt::Horizontal, min, max);
                     axes->axisX()->setRange(min, max);
                 }
                 // Initialize axis Y
                 if (axes->axisY()) {
                     axes->emitAxisYChanged();
                 } else if (axes->axisYRight()) {
                     axes->emitAxisYRightChanged();
                 } else {
                     axes->setAxisY(defaultAxis(Qt::Vertical, series));
                     findMinMaxForSeries(series, Qt::Vertical, min, max);
                     axes->axisY()->setRange(min, max);
                 }
             }
             void DeclarativeChart::findMinMaxForSeries(QAbstractSeries *series, Qt::Orientations orientation,
                                                        qreal &min, qreal &max)
             {
                 if (!series) {
                     min = 0.5;
                     max = 0.5;
                 } else {
                     AbstractDomain *domain = series->d_ptr->domain();
                     min = (orientation == Qt::Vertical) ? domain->minY() : domain->minX();
                     max = (orientation == Qt::Vertical) ? domain->maxY() : domain->maxX();
                     if (min == max) {
                         min -= 0.5;
                         max += 0.5;
                     }
                 }
             }
             QPointF DeclarativeChart::mapToValue(const QPointF &position, QAbstractSeries *series)
             {
                 return m_chart->mapToValue(position, series);
             }
             QPointF DeclarativeChart::mapToPosition(const QPointF &value, QAbstractSeries *series)
             {
                 return m_chart->mapToPosition(value, series);
             }
             #include "moc_declarativechart.cpp"
             QT_CHARTS_END_NAMESPACE

src/chartsqml2/declarativechart.h +8 -6

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #ifndef DECLARATIVECHART_H
             #define DECLARATIVECHART_H
+            #include <private/glxyseriesdata_p.h>
             #include <QtCore/QtGlobal>
             #include <QtQuick/QQuickItem>
-            #include <QtQuick/QQuickPaintedItem>
             #include <QtWidgets/QGraphicsScene>
-            #include <QtCore/QMutex>
             #include <QtCharts/QChart>
             #include <QtCore/QLocale>
             QT_CHARTS_BEGIN_NAMESPACE
             class DeclarativeMargins;
             class Domain;
             class DeclarativeAxes;
-            class DeclarativeChart : public QQuickPaintedItem
+            class DeclarativeChart : public QQuickItem
             {
                 Q_OBJECT
                 Q_PROPERTY(Theme theme READ theme WRITE setTheme)
                 Q_PROPERTY(Animation animationOptions READ animationOptions WRITE setAnimationOptions)
                 Q_PROPERTY(int animationDuration READ animationDuration WRITE setAnimationDuration NOTIFY animationDurationChanged REVISION 5)
                 Q_PROPERTY(QEasingCurve animationEasingCurve READ animationEasingCurve WRITE setAnimationEasingCurve NOTIFY animationEasingCurveChanged REVISION 5)
                 Q_PROPERTY(QString title READ title WRITE setTitle)
                 Q_PROPERTY(QFont titleFont READ titleFont WRITE setTitleFont)
                 Q_PROPERTY(QColor titleColor READ titleColor WRITE setTitleColor NOTIFY titleColorChanged)
                 Q_PROPERTY(QLegend *legend READ legend CONSTANT)
                 Q_PROPERTY(int count READ count)
                 Q_PROPERTY(QColor backgroundColor READ backgroundColor WRITE setBackgroundColor NOTIFY backgroundColorChanged)
                 Q_PROPERTY(bool dropShadowEnabled READ dropShadowEnabled WRITE setDropShadowEnabled NOTIFY dropShadowEnabledChanged)
                 Q_PROPERTY(qreal backgroundRoundness READ backgroundRoundness WRITE setBackgroundRoundness NOTIFY backgroundRoundnessChanged REVISION 3)
                 Q_PROPERTY(DeclarativeMargins *margins READ margins NOTIFY marginsChanged REVISION 2)
                 Q_PROPERTY(QRectF plotArea READ plotArea NOTIFY plotAreaChanged REVISION 1)
                 Q_PROPERTY(QColor plotAreaColor READ plotAreaColor WRITE setPlotAreaColor NOTIFY plotAreaColorChanged REVISION 3)
                 Q_PROPERTY(QQmlListProperty<QAbstractAxis> axes READ axes REVISION 2)
                 Q_PROPERTY(bool localizeNumbers READ localizeNumbers WRITE setLocalizeNumbers NOTIFY localizeNumbersChanged REVISION 4)
                 Q_PROPERTY(QLocale locale READ locale WRITE setLocale NOTIFY localeChanged REVISION 4)
                 Q_ENUMS(Animation)
                 Q_ENUMS(Theme)
                 Q_ENUMS(SeriesType)
             public:
                 // duplicating enums from QChart to make the QML api namings 1-to-1 with the C++ api
                 enum Theme {
                     ChartThemeLight = 0,
                     ChartThemeBlueCerulean,
                     ChartThemeDark,
                     ChartThemeBrownSand,
                     ChartThemeBlueNcs,
                     ChartThemeHighContrast,
                     ChartThemeBlueIcy,
                     ChartThemeQt
                 };
                 enum Animation {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations = 0x2,
                     AllAnimations = 0x3
                 };
                 enum SeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypeBoxPlot,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline,
                     SeriesTypeHorizontalBar,
                     SeriesTypeHorizontalStackedBar,
                     SeriesTypeHorizontalPercentBar
                 };
             public:
                 DeclarativeChart(QQuickItem *parent = 0);
                 ~DeclarativeChart();
             public: // From parent classes
                 void childEvent(QChildEvent *event);
                 void componentComplete();
                 void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
-                void paint(QPainter *painter);
+                QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *);
             protected:
                 void mousePressEvent(QMouseEvent *event);
                 void mouseReleaseEvent(QMouseEvent *event);
                 void hoverMoveEvent(QHoverEvent *event);
                 void mouseDoubleClickEvent(QMouseEvent *event);
             private Q_SLOTS:
                 void handleAntialiasingChanged(bool enable);
                 void sceneChanged(QList<QRectF> region);
                 void renderScene();
             public:
                 void setTheme(DeclarativeChart::Theme theme);
                 DeclarativeChart::Theme theme();
                 void setAnimationOptions(DeclarativeChart::Animation animations);
                 DeclarativeChart::Animation animationOptions();
                 void setAnimationDuration(int msecs);
                 int animationDuration() const;
                 void setAnimationEasingCurve(const QEasingCurve &curve);
                 QEasingCurve animationEasingCurve() const;
                 void setTitle(QString title);
                 QString title();
                 QLegend *legend();
                 QFont titleFont() const;
                 void setTitleFont(const QFont &font);
                 void setTitleColor(QColor color);
                 QColor titleColor();
                 void setBackgroundColor(QColor color);
                 QColor backgroundColor();
                 void setPlotAreaColor(QColor color);
                 QColor plotAreaColor();
                 void setLocalizeNumbers(bool localize);
                 bool localizeNumbers() const;
                 void setLocale(const QLocale &locale);
                 QLocale locale() const;
                 int count();
                 void setDropShadowEnabled(bool enabled);
                 bool dropShadowEnabled();
                 qreal backgroundRoundness() const;
                 void setBackgroundRoundness(qreal diameter);
                 // Margins & plotArea
                 DeclarativeMargins *margins() { return m_margins; }
                 QRectF plotArea() { return m_chart->plotArea(); }
                 // Axis handling
                 QAbstractAxis *defaultAxis(Qt::Orientation orientation, QAbstractSeries *series);
                 void initializeAxes(QAbstractSeries *series);
                 void doInitializeAxes(QAbstractSeries *series, DeclarativeAxes *axes);
                 QQmlListProperty<QAbstractAxis> axes();
                 static void axesAppendFunc(QQmlListProperty<QAbstractAxis> *list, QAbstractAxis *element);
                 static int axesCountFunc(QQmlListProperty<QAbstractAxis> *list);
                 static QAbstractAxis *axesAtFunc(QQmlListProperty<QAbstractAxis> *list, int index);
                 static void axesClearFunc(QQmlListProperty<QAbstractAxis> *list);
             public:
                 Q_INVOKABLE QAbstractSeries *series(int index);
                 Q_INVOKABLE QAbstractSeries *series(QString seriesName);
                 Q_INVOKABLE QAbstractSeries *createSeries(int type, QString name = "", QAbstractAxis *axisX = 0, QAbstractAxis *axisY = 0);
                 Q_INVOKABLE void removeSeries(QAbstractSeries *series);
                 Q_INVOKABLE void removeAllSeries() { m_chart->removeAllSeries(); }
                 Q_INVOKABLE void setAxisX(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 Q_INVOKABLE void setAxisY(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 Q_INVOKABLE QAbstractAxis *axisX(QAbstractSeries *series = 0);
                 Q_INVOKABLE QAbstractAxis *axisY(QAbstractSeries *series = 0);
                 Q_INVOKABLE void zoom(qreal factor);
                 Q_REVISION(5) Q_INVOKABLE void zoomIn();
                 Q_REVISION(5) Q_INVOKABLE void zoomIn(const QRectF &rectangle);
                 Q_REVISION(5) Q_INVOKABLE void zoomOut();
                 Q_REVISION(5) Q_INVOKABLE void zoomReset();
                 Q_REVISION(5) Q_INVOKABLE bool isZoomed();
                 Q_INVOKABLE void scrollLeft(qreal pixels);
                 Q_INVOKABLE void scrollRight(qreal pixels);
                 Q_INVOKABLE void scrollUp(qreal pixels);
                 Q_INVOKABLE void scrollDown(qreal pixels);
                 Q_REVISION(5) Q_INVOKABLE QPointF mapToValue(const QPointF &position,
                                                              QAbstractSeries *series = 0);
                 Q_REVISION(5) Q_INVOKABLE QPointF mapToPosition(const QPointF &value,
                                                                 QAbstractSeries *series = 0);
             Q_SIGNALS:
                 void axisLabelsChanged();
                 void titleColorChanged(QColor color);
                 void backgroundColorChanged();
                 void dropShadowEnabledChanged(bool enabled);
                 Q_REVISION(2) void marginsChanged();
                 void plotAreaChanged(QRectF plotArea);
                 void seriesAdded(QAbstractSeries *series);
                 void seriesRemoved(QAbstractSeries *series);
                 Q_REVISION(3) void plotAreaColorChanged();
                 Q_REVISION(3) void backgroundRoundnessChanged(qreal diameter);
                 Q_REVISION(4) void localizeNumbersChanged();
                 Q_REVISION(4) void localeChanged();
                 Q_REVISION(5) void animationDurationChanged(int msecs);
                 Q_REVISION(5) void animationEasingCurveChanged(QEasingCurve curve);
+                void needRender();
             private Q_SLOTS:
                 void changeMargins(int top, int bottom, int left, int right);
                 void handleAxisXSet(QAbstractAxis *axis);
                 void handleAxisYSet(QAbstractAxis *axis);
                 void handleAxisXTopSet(QAbstractAxis *axis);
                 void handleAxisYRightSet(QAbstractAxis *axis);
                 void handleSeriesAdded(QAbstractSeries *series);
             protected:
                 explicit DeclarativeChart(QChart::ChartType type, QQuickItem *parent);
             private:
                 void initChart(QChart::ChartType type);
                 void seriesAxisAttachHelper(QAbstractSeries *series, QAbstractAxis *axis,
                                             Qt::Orientations orientation, Qt::Alignment alignment);
                 void findMinMaxForSeries(QAbstractSeries *series,Qt::Orientations orientation,
                                          qreal &min, qreal &max);
                 // Extending QChart with DeclarativeChart is not possible because QObject does not support
                 // multi inheritance, so we now have a QChart as a member instead
                 QChart *m_chart;
                 QGraphicsScene *m_scene;
                 QPointF m_mousePressScenePoint;
                 QPoint m_mousePressScreenPoint;
                 QPointF m_lastMouseMoveScenePoint;
                 QPoint m_lastMouseMoveScreenPoint;
                 Qt::MouseButton m_mousePressButton;
                 Qt::MouseButtons m_mousePressButtons;
-                QMutex m_sceneImageLock;
+                QImage *m_sceneImage;
-                QImage *m_currentSceneImage;
+                bool m_sceneImageDirty;
                 bool m_updatePending;
                 Qt::HANDLE m_paintThreadId;
                 Qt::HANDLE m_guiThreadId;
                 DeclarativeMargins *m_margins;
+                GLXYSeriesDataManager *m_glXYDataManager;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // DECLARATIVECHART_H

tests/auto/qlineseries/tst_qlineseries.cpp +2 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include "../qxyseries/tst_qxyseries.h"
             #include <QtCharts/QLineSeries>
             Q_DECLARE_METATYPE(QList<QPointF>)
+            Q_DECLARE_METATYPE(QVector<QPointF>)
             class tst_QLineSeries : public tst_QXYSeries
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qlineseries_data();
                 void qlineseries();
                 void pressedSignal();
                 void releasedSignal();
                 void doubleClickedSignal();
                 void insert();
             protected:
                 void pointsVisible_data();
             };
             void tst_QLineSeries::initTestCase()
             {
             }
             void tst_QLineSeries::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QLineSeries::init()
             {
                 tst_QXYSeries::init();
                 m_series = new QLineSeries();
             }
             void tst_QLineSeries::cleanup()
             {
                 delete m_series;
                 m_series=0;
                 tst_QXYSeries::cleanup();
             }
             void tst_QLineSeries::qlineseries_data()
             {
             }
             void tst_QLineSeries::qlineseries()
             {
                 QLineSeries series;
                 QCOMPARE(series.count(),0);
                 QCOMPARE(series.brush(), QBrush());
                 QCOMPARE(series.points(), QList<QPointF>());
+                QCOMPARE(series.pointsVector(), QVector<QPointF>());
                 QCOMPARE(series.pen(), QPen());
                 QCOMPARE(series.pointsVisible(), false);
                 QCOMPARE(series.pointLabelsVisible(), false);
                 QCOMPARE(series.pointLabelsFormat(), QLatin1String("@xPoint, @yPoint"));
                 QCOMPARE(series.pointLabelsClipping(), true);
                 series.append(QList<QPointF>());
                 series.append(0.0,0.0);
                 series.append(QPointF());
                 series.remove(0.0,0.0);
                 series.remove(QPointF());
                 series.clear();
                 series.replace(QPointF(),QPointF());
                 series.replace(0,0,0,0);
                 series.setBrush(QBrush());
                 series.setPen(QPen());
                 series.setPointsVisible(false);
                 series.setPointLabelsVisible(false);
                 series.setPointLabelsFormat(QString());
                 m_chart->addSeries(&series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QLineSeries::pressedSignal()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPointF linePoint(4, 12);
                 QLineSeries *lineSeries = new QLineSeries();
                 lineSeries->append(QPointF(2, 1));
                 lineSeries->append(linePoint);
                 lineSeries->append(QPointF(6, 12));
                 QChartView view;
                 view.chart()->legend()->setVisible(false);
                 view.chart()->addSeries(lineSeries);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 QSignalSpy seriesSpy(lineSeries, SIGNAL(pressed(QPointF)));
                 QPointF checkPoint = view.chart()->mapToPosition(linePoint);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
                 // this causes small distinction in decimals so we round it before comparing
                 QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
                 QCOMPARE(qRound(signalPoint.x()), qRound(linePoint.x()));
                 QCOMPARE(qRound(signalPoint.y()), qRound(linePoint.y()));
             }
             void tst_QLineSeries::releasedSignal()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPointF linePoint(4, 12);
                 QLineSeries *lineSeries = new QLineSeries();
                 lineSeries->append(QPointF(2, 20));
                 lineSeries->append(linePoint);
                 lineSeries->append(QPointF(6, 12));
                 QChartView view;
                 view.chart()->legend()->setVisible(false);
                 view.chart()->addSeries(lineSeries);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 QSignalSpy seriesSpy(lineSeries, SIGNAL(released(QPointF)));
                 QPointF checkPoint = view.chart()->mapToPosition(linePoint);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
                 // this causes small distinction in decimals so we round it before comparing
                 QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
                 QCOMPARE(qRound(signalPoint.x()), qRound(linePoint.x()));
                 QCOMPARE(qRound(signalPoint.y()), qRound(linePoint.y()));
             }
             void tst_QLineSeries::insert()
             {
                 QLineSeries lineSeries;
                 QSignalSpy insertSpy(&lineSeries, &QXYSeries::pointAdded);
                 lineSeries.insert(0, QPoint(3, 3));
                 QCOMPARE(insertSpy.count(), 1);
                 QVariantList arguments = insertSpy.takeFirst();
                 QCOMPARE(arguments.first().toInt(), 0);
                 lineSeries.insert(0, QPoint(1, 1));
                 arguments = insertSpy.takeFirst();
                 QCOMPARE(arguments.first().toInt(), 0);
                 lineSeries.insert(1, QPoint(2, 2));
                 arguments = insertSpy.takeFirst();
                 QCOMPARE(arguments.first().toInt(), 1);
                 lineSeries.insert(42, QPoint(0, 0));
                 arguments = insertSpy.takeFirst();
                 QCOMPARE(arguments.first().toInt(), 3);
                 lineSeries.insert(-42, QPoint(0, 0));
                 arguments = insertSpy.takeFirst();
                 QCOMPARE(arguments.first().toInt(), 0);
             }
             void tst_QLineSeries::doubleClickedSignal()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPointF linePoint(4, 12);
                 QLineSeries *lineSeries = new QLineSeries();
                 lineSeries->append(QPointF(2, 20));
                 lineSeries->append(linePoint);
                 lineSeries->append(QPointF(6, 12));
                 QChartView view;
                 view.chart()->legend()->setVisible(false);
                 view.chart()->addSeries(lineSeries);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 QSignalSpy seriesSpy(lineSeries, SIGNAL(doubleClicked(QPointF)));
                 QPointF checkPoint = view.chart()->mapToPosition(linePoint);
                 // mouseClick needed first to save the position
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
                 // this causes small distinction in decimals so we round it before comparing
                 QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
                 QCOMPARE(qRound(signalPoint.x()), qRound(linePoint.x()));
                 QCOMPARE(qRound(signalPoint.y()), qRound(linePoint.y()));
             }
             QTEST_MAIN(tst_QLineSeries)
             #include "tst_qlineseries.moc"

tests/auto/qscatterseries/tst_qscatterseries.cpp +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include "../qxyseries/tst_qxyseries.h"
             #include <QtCharts/QScatterSeries>
             Q_DECLARE_METATYPE(QList<QPointF>)
+            Q_DECLARE_METATYPE(QVector<QPointF>)
             class tst_QScatterSeries : public tst_QXYSeries
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qscatterseries_data();
                 void qscatterseries();
                 void scatterChangedSignals();
                 void pressedSignal();
                 void releasedSignal();
                 void doubleClickedSignal();
             protected:
                 void pointsVisible_data();
             };
             void tst_QScatterSeries::initTestCase()
             {
             }
             void tst_QScatterSeries::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QScatterSeries::init()
             {
                 tst_QXYSeries::init();
                 m_series = new QScatterSeries();
             }
             void tst_QScatterSeries::cleanup()
             {
                 delete m_series;
                 tst_QXYSeries::cleanup();
             }
             void tst_QScatterSeries::qscatterseries_data()
             {
             }
             void tst_QScatterSeries::qscatterseries()
             {
                 QScatterSeries series;
                 QCOMPARE(series.count(),0);
                 QCOMPARE(series.brush(), QBrush());
                 QCOMPARE(series.points(), QList<QPointF>());
+                QCOMPARE(series.pointsVector(), QVector<QPointF>());
                 QCOMPARE(series.pen(), QPen());
                 QCOMPARE(series.pointsVisible(), false);
                 series.append(QList<QPointF>());
                 series.append(0.0,0.0);
                 series.append(QPointF());
                 series.remove(0.0,0.0);
                 series.remove(QPointF());
                 series.clear();
                 series.replace(QPointF(),QPointF());
                 series.replace(0,0,0,0);
                 series.setBrush(QBrush());
                 series.setPen(QPen());
                 series.setPointsVisible(false);
                 m_chart->addSeries(&series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QScatterSeries::scatterChangedSignals()
             {
                 QScatterSeries *series = qobject_cast<QScatterSeries *>(m_series);
                 QVERIFY(series);
                 QSignalSpy colorSpy(series, SIGNAL(colorChanged(QColor)));
                 QSignalSpy borderColorSpy(series, SIGNAL(borderColorChanged(QColor)));
                 // Color
                 series->setColor(QColor("blueviolet"));
                 TRY_COMPARE(colorSpy.count(), 1);
                 // Border color
                 series->setBorderColor(QColor("burlywood"));
                 TRY_COMPARE(borderColorSpy.count(), 1);
                 // Pen
                 QPen p = series->pen();
                 p.setColor("lightpink");
                 series->setPen(p);
                 TRY_COMPARE(borderColorSpy.count(), 2);
                 // Brush
                 QBrush b = series->brush();
                 b.setColor("lime");
                 series->setBrush(b);
                 TRY_COMPARE(colorSpy.count(), 2);
             }
             void tst_QScatterSeries::pressedSignal()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPointF scatterPoint(4, 12);
                 QScatterSeries *scatterSeries = new QScatterSeries();
                 scatterSeries->append(QPointF(2, 1));
                 scatterSeries->append(scatterPoint);
                 scatterSeries->append(QPointF(6, 12));
                 QChartView view;
                 view.chart()->legend()->setVisible(false);
                 view.chart()->addSeries(scatterSeries);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 QSignalSpy seriesSpy(scatterSeries, SIGNAL(pressed(QPointF)));
                 QPointF checkPoint = view.chart()->mapToPosition(scatterPoint);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
                 // this causes small distinction in decimals so we round it before comparing
                 QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
                 QCOMPARE(qRound(signalPoint.x()), qRound(scatterPoint.x()));
                 QCOMPARE(qRound(signalPoint.y()), qRound(scatterPoint.y()));
             }
             void tst_QScatterSeries::releasedSignal()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPointF scatterPoint(4, 12);
                 QScatterSeries *scatterSeries = new QScatterSeries();
                 scatterSeries->append(QPointF(2, 1));
                 scatterSeries->append(scatterPoint);
                 scatterSeries->append(QPointF(6, 12));
                 QChartView view;
                 view.chart()->legend()->setVisible(false);
                 view.chart()->addSeries(scatterSeries);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 QSignalSpy seriesSpy(scatterSeries, SIGNAL(released(QPointF)));
                 QPointF checkPoint = view.chart()->mapToPosition(scatterPoint);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
                 // this causes small distinction in decimals so we round it before comparing
                 QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
                 QCOMPARE(qRound(signalPoint.x()), qRound(scatterPoint.x()));
                 QCOMPARE(qRound(signalPoint.y()), qRound(scatterPoint.y()));
             }
             void tst_QScatterSeries::doubleClickedSignal()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPointF scatterPoint(4, 12);
                 QScatterSeries *scatterSeries = new QScatterSeries();
                 scatterSeries->append(QPointF(2, 1));
                 scatterSeries->append(scatterPoint);
                 scatterSeries->append(QPointF(6, 12));
                 QChartView view;
                 view.chart()->legend()->setVisible(false);
                 view.chart()->addSeries(scatterSeries);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 QSignalSpy seriesSpy(scatterSeries, SIGNAL(doubleClicked(QPointF)));
                 QPointF checkPoint = view.chart()->mapToPosition(scatterPoint);
                 QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
                 // this causes small distinction in decimals so we round it before comparing
                 QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
                 QCOMPARE(qRound(signalPoint.x()), qRound(scatterPoint.x()));
                 QCOMPARE(qRound(signalPoint.y()), qRound(scatterPoint.y()));
             }
             QTEST_MAIN(tst_QScatterSeries)
             #include "tst_qscatterseries.moc"

tests/auto/qsplineseries/tst_qsplineseries.cpp +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include "../qxyseries/tst_qxyseries.h"
             #include <QtCharts/QSplineSeries>
             Q_DECLARE_METATYPE(QList<QPointF>)
+            Q_DECLARE_METATYPE(QVector<QPointF>)
             class tst_QSplineSeries : public tst_QXYSeries
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qsplineseries_data();
                 void qsplineseries();
                 void pressedSignal();
                 void releasedSignal();
                 void doubleClickedSignal();
             protected:
                 void pointsVisible_data();
             };
             void tst_QSplineSeries::initTestCase()
             {
             }
             void tst_QSplineSeries::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QSplineSeries::init()
             {
                 tst_QXYSeries::init();
                 m_series = new QSplineSeries();
             }
             void tst_QSplineSeries::cleanup()
             {
                 delete m_series;
                 tst_QXYSeries::cleanup();
             }
             void tst_QSplineSeries::qsplineseries_data()
             {
             }
             void tst_QSplineSeries::qsplineseries()
             {
                 QSplineSeries series;
                 QCOMPARE(series.count(),0);
                 QCOMPARE(series.brush(), QBrush());
                 QCOMPARE(series.points(), QList<QPointF>());
+                QCOMPARE(series.pointsVector(), QVector<QPointF>());
                 QCOMPARE(series.pen(), QPen());
                 QCOMPARE(series.pointsVisible(), false);
                 series.append(QList<QPointF>());
                 series.append(0.0,0.0);
                 series.append(QPointF());
                 series.remove(0.0,0.0);
                 series.remove(QPointF());
                 series.clear();
                 series.replace(QPointF(),QPointF());
                 series.replace(0,0,0,0);
                 series.setBrush(QBrush());
                 series.setPen(QPen());
                 series.setPointsVisible(false);
                 m_chart->addSeries(&series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QSplineSeries::pressedSignal()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPointF splinePoint(4, 12);
                 QSplineSeries *splineSeries = new QSplineSeries();
                 splineSeries->append(QPointF(2, 1));
                 splineSeries->append(splinePoint);
                 splineSeries->append(QPointF(6, 12));
                 QChartView view;
                 view.chart()->legend()->setVisible(false);
                 view.chart()->addSeries(splineSeries);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 QSignalSpy seriesSpy(splineSeries, SIGNAL(pressed(QPointF)));
                 QPointF checkPoint = view.chart()->mapToPosition(splinePoint);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
                 // this causes small distinction in decimals so we round it before comparing
                 QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
                 QCOMPARE(qRound(signalPoint.x()), qRound(splinePoint.x()));
                 QCOMPARE(qRound(signalPoint.y()), qRound(splinePoint.y()));
             }
             void tst_QSplineSeries::releasedSignal()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPointF splinePoint(4, 12);
                 QSplineSeries *splineSeries = new QSplineSeries();
                 splineSeries->append(QPointF(2, 20));
                 splineSeries->append(splinePoint);
                 splineSeries->append(QPointF(6, 12));
                 QChartView view;
                 view.chart()->legend()->setVisible(false);
                 view.chart()->addSeries(splineSeries);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 QSignalSpy seriesSpy(splineSeries, SIGNAL(released(QPointF)));
                 QPointF checkPoint = view.chart()->mapToPosition(splinePoint);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
                 // this causes small distinction in decimals so we round it before comparing
                 QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
                 QCOMPARE(qRound(signalPoint.x()), qRound(splinePoint.x()));
                 QCOMPARE(qRound(signalPoint.y()), qRound(splinePoint.y()));
             }
             void tst_QSplineSeries::doubleClickedSignal()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 QPointF splinePoint(4, 12);
                 QSplineSeries *splineSeries = new QSplineSeries();
                 splineSeries->append(QPointF(2, 20));
                 splineSeries->append(splinePoint);
                 splineSeries->append(QPointF(6, 12));
                 QChartView view;
                 view.chart()->legend()->setVisible(false);
                 view.chart()->addSeries(splineSeries);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 QSignalSpy seriesSpy(splineSeries, SIGNAL(doubleClicked(QPointF)));
                 QPointF checkPoint = view.chart()->mapToPosition(splinePoint);
                 // mouseClick needed first to save the position
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, checkPoint.toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 // checkPoint is QPointF and for the mouseClick it it's changed to QPoint
                 // this causes small distinction in decimals so we round it before comparing
                 QPointF signalPoint = qvariant_cast<QPointF>(seriesSpyArg.at(0));
                 QCOMPARE(qRound(signalPoint.x()), qRound(splinePoint.x()));
                 QCOMPARE(qRound(signalPoint.y()), qRound(splinePoint.y()));
             }
             QTEST_MAIN(tst_QSplineSeries)
             #include "tst_qsplineseries.moc"

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

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include "tst_qxyseries.h"
             Q_DECLARE_METATYPE(QList<QPointF>)
             void tst_QXYSeries::initTestCase()
             {
             }
             void tst_QXYSeries::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             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::pointLabelsFormat()
             {
                 QSignalSpy labelsFormatSpy(m_series, SIGNAL(pointLabelsFormatChanged(QString)));
                 QCOMPARE(m_series->pointLabelsFormat(), QLatin1String("@xPoint, @yPoint"));
                 QString format("@yPoint");
                 m_series->setPointLabelsFormat(format);
                 TRY_COMPARE(labelsFormatSpy.count(), 1);
                 QList<QVariant> arguments = labelsFormatSpy.takeFirst();
                 QVERIFY(arguments.at(0).toString() == format);
                 m_series->setPointLabelsFormat(QString());
                 TRY_COMPARE(labelsFormatSpy.count(), 1);
                 arguments = labelsFormatSpy.takeFirst();
                 QVERIFY(arguments.at(0).toString() == QString());
             }
             void tst_QXYSeries::pointLabelsVisible()
             {
                 QSignalSpy labelsVisibleSpy(m_series, SIGNAL(pointLabelsVisibilityChanged(bool)));
                 QCOMPARE(m_series->pointLabelsVisible(), false);
                 m_series->setPointLabelsVisible();
                 QCOMPARE(m_series->pointLabelsVisible(), true);
                 TRY_COMPARE(labelsVisibleSpy.count(), 1);
                 QList<QVariant> arguments = labelsVisibleSpy.takeFirst();
                 QVERIFY(arguments.at(0).toBool() == true);
                 m_series->setPointLabelsVisible(false);
                 QCOMPARE(m_series->pointLabelsVisible(), false);
                 TRY_COMPARE(labelsVisibleSpy.count(), 1);
                 arguments = labelsVisibleSpy.takeFirst();
                 QVERIFY(arguments.at(0).toBool() == false);
             }
             void tst_QXYSeries::pointLabelsFont()
             {
                 QFont defaultFont(m_series->pointLabelsFont());
                 QSignalSpy labelsFontSpy(m_series, SIGNAL(pointLabelsFontChanged(QFont)));
                 QFont font("Times", 10);
                 m_series->setPointLabelsFont(font);
                 TRY_COMPARE(labelsFontSpy.count(), 1);
                 QList<QVariant> arguments = labelsFontSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QFont>() == font);
                 m_series->setPointLabelsFont(defaultFont);
                 TRY_COMPARE(labelsFontSpy.count(), 1);
                 arguments = labelsFontSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QFont>() == defaultFont);
             }
             void tst_QXYSeries::pointLabelsColor()
             {
                 QColor defaultColor(QPen().color());
                 QSignalSpy labelsColorSpy(m_series, SIGNAL(pointLabelsColorChanged(QColor)));
                 QCOMPARE(m_series->pointLabelsColor(), defaultColor);
                 QColor color(Qt::blue);
                 m_series->setPointLabelsColor(color);
                 TRY_COMPARE(labelsColorSpy.count(), 1);
                 QList<QVariant> arguments = labelsColorSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QColor>() == color);
                 m_series->setPointLabelsColor(defaultColor);
                 TRY_COMPARE(labelsColorSpy.count(), 1);
                 arguments = labelsColorSpy.takeFirst();
                 QVERIFY(arguments.at(0).value<QColor>() == defaultColor);
             }
             void tst_QXYSeries::pointLabelsClipping()
             {
                 QSignalSpy labelsClippingSpy(m_series, SIGNAL(pointLabelsClippingChanged(bool)));
                 QCOMPARE(m_series->pointLabelsClipping(), true);
                 m_series->setPointLabelsClipping(false);
                 QCOMPARE(m_series->pointLabelsClipping(), false);
                 TRY_COMPARE(labelsClippingSpy.count(), 1);
                 QList<QVariant> arguments = labelsClippingSpy.takeFirst();
                 QVERIFY(arguments.at(0).toBool() == false);
                 m_series->setPointLabelsClipping();
                 QCOMPARE(m_series->pointLabelsClipping(), true);
                 TRY_COMPARE(labelsClippingSpy.count(), 1);
                 arguments = labelsClippingSpy.takeFirst();
                 QVERIFY(arguments.at(0).toBool() == true);
             }
             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);
+                QCOMPARE(m_series->pointsVector(), points.toVector());
                 // 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);
                 // Multiple 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->removePoints(5, 2);
                 m_series->removePoints(0, 3);
                 QCOMPARE(m_series->points().count(), (bunchOfPoints.count() - 5));
                 m_series->removePoints(0, (bunchOfPoints.count() - 5));
                 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);
             }

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