HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2483:f494279b6366

Add Polar chart support...

Miikka Heikkinen -

r2483:f494279b6366

parent child

Context file:

r2483:f494279b6366

Expand all files

demos/qmlpolarchart/main.cpp created 644 +36 0

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

demos/qmlpolarchart/qml/qmlpolarchart/View1.qml created 644 +68 0

@@ -0,0 +1,68
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	import QtQuick 1.0
	22	import QtCommercial.Chart 1.3
	23
	24	Rectangle {
	25	anchors.fill: parent
	26	//![1]
	27	PolarChartView {
	28	title: "Two Series, Common Axes"
	29	anchors.fill: parent
	30	legend.visible: false
	31
	32	ValueAxis {
	33	id: axisAngular
	34	min: 0
	35	max: 20
	36	tickCount: 9
	37	}
	38
	39	ValueAxis {
	40	id: axisRadial
	41	min: -0.5
	42	max: 1.5
	43	}
	44
	45	SplineSeries {
	46	id: series1
	47	axisAngular: axisAngular
	48	axisRadial: axisRadial
	49	pointsVisible: true
	50	}
	51
	52	ScatterSeries {
	53	id: series2
	54	axisAngular: axisAngular
	55	axisRadial: axisRadial
	56	markerSize: 10
	57	}
	58	}
	59
	60	// Add data dynamically to the series
	61	Component.onCompleted: {
	62	for (var i = 0; i <= 20; i++) {
	63	series1.append(i, Math.random());
	64	series2.append(i, Math.random());
	65	}
	66	}
	67	//![1]
	68	}

demos/qmlpolarchart/qml/qmlpolarchart/View2.qml created 644 +89 0

@@ -0,0 +1,89
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	import QtQuick 1.0
	22	import QtCommercial.Chart 1.3
	23
	24	Rectangle {
	25	anchors.fill: parent
	26
	27	//![1]
	28	PolarChartView {
	29	title: "Historical Area Series"
	30	anchors.fill: parent
	31	legend.visible: false
	32
	33	DateTimeAxis {
	34	id: axis1
	35	format: "yyyy MMM"
	36	tickCount: 13
	37	}
	38	ValueAxis {
	39	id: axis2
	40	}
	41	LineSeries {
	42	id: lowerLine
	43	axisAngular: axis1
	44	axisRadial: axis2
	45
	46	// Please note that month in JavaScript months are zero based, so 2 means March
	47	XYPoint { x: toMsecsSinceEpoch(new Date(1950, 0, 1)); y: 15 }
	48	XYPoint { x: toMsecsSinceEpoch(new Date(1962, 4, 1)); y: 35 }
	49	XYPoint { x: toMsecsSinceEpoch(new Date(1970, 0, 1)); y: 50 }
	50	XYPoint { x: toMsecsSinceEpoch(new Date(1978, 2, 1)); y: 75 }
	51	XYPoint { x: toMsecsSinceEpoch(new Date(1987, 11, 1)); y: 102 }
	52	XYPoint { x: toMsecsSinceEpoch(new Date(1992, 1, 1)); y: 132 }
	53	XYPoint { x: toMsecsSinceEpoch(new Date(1998, 7, 1)); y: 100 }
	54	XYPoint { x: toMsecsSinceEpoch(new Date(2002, 4, 1)); y: 120 }
	55	XYPoint { x: toMsecsSinceEpoch(new Date(2012, 8, 1)); y: 140 }
	56	XYPoint { x: toMsecsSinceEpoch(new Date(2013, 5, 1)); y: 150 }
	57	}
	58	LineSeries {
	59	id: upperLine
	60	axisAngular: axis1
	61	axisRadial: axis2
	62
	63	// Please note that month in JavaScript months are zero based, so 2 means March
	64	XYPoint { x: toMsecsSinceEpoch(new Date(1950, 0, 1)); y: 30 }
	65	XYPoint { x: toMsecsSinceEpoch(new Date(1962, 4, 1)); y: 55 }
	66	XYPoint { x: toMsecsSinceEpoch(new Date(1970, 0, 1)); y: 80 }
	67	XYPoint { x: toMsecsSinceEpoch(new Date(1978, 2, 1)); y: 105 }
	68	XYPoint { x: toMsecsSinceEpoch(new Date(1987, 11, 1)); y: 125 }
	69	XYPoint { x: toMsecsSinceEpoch(new Date(1992, 1, 1)); y: 160 }
	70	XYPoint { x: toMsecsSinceEpoch(new Date(1998, 7, 1)); y: 140 }
	71	XYPoint { x: toMsecsSinceEpoch(new Date(2002, 4, 1)); y: 140 }
	72	XYPoint { x: toMsecsSinceEpoch(new Date(2012, 8, 1)); y: 170 }
	73	XYPoint { x: toMsecsSinceEpoch(new Date(2013, 5, 1)); y: 200 }
	74	}
	75	AreaSeries {
	76	axisAngular: axis1
	77	axisRadial: axis2
	78	lowerSeries: lowerLine
	79	upperSeries: upperLine
	80	}
	81	}
	82	// DateTimeAxis is based on QDateTimes so we must convert our JavaScript dates to
	83	// milliseconds since epoch to make them match the DateTimeAxis values
	84	function toMsecsSinceEpoch(date) {
	85	var msecs = date.getTime();
	86	return msecs;
	87	}
	88	//![1]
	89	}

demos/qmlpolarchart/qml/qmlpolarchart/View3.qml created 644 +76 0

@@ -0,0 +1,76
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	import QtQuick 1.0
	22	import QtCommercial.Chart 1.3
	23
	24	Rectangle {
	25	anchors.fill: parent
	26
	27	//![1]
	28	PolarChartView {
	29	title: "Numerical Data for Dummies"
	30	anchors.fill: parent
	31	legend.visible: false
	32
	33	LineSeries {
	34	axisRadial: CategoryAxis {
	35	min: 0
	36	max: 30
	37	CategoryRange {
	38	label: "critical"
	39	endValue: 2
	40	}
	41	CategoryRange {
	42	label: "low"
	43	endValue: 4
	44	}
	45	CategoryRange {
	46	label: "normal"
	47	endValue: 7
	48	}
	49	CategoryRange {
	50	label: "high"
	51	endValue: 15
	52	}
	53	CategoryRange {
	54	label: "extremely high"
	55	endValue: 30
	56	}
	57	}
	58
	59	axisAngular: ValueAxis {
	60	tickCount: 13
	61	}
	62
	63	XYPoint { x: 0; y: 4.3 }
	64	XYPoint { x: 1; y: 4.1 }
	65	XYPoint { x: 2; y: 4.7 }
	66	XYPoint { x: 3; y: 3.9 }
	67	XYPoint { x: 4; y: 5.2 }
	68	XYPoint { x: 5; y: 5.3 }
	69	XYPoint { x: 6; y: 6.1 }
	70	XYPoint { x: 7; y: 7.7 }
	71	XYPoint { x: 8; y: 12.9 }
	72	XYPoint { x: 9; y: 19.2 }
	73	}
	74	}
	75	//![1]
	76	}

demos/qmlpolarchart/qml/qmlpolarchart/loader.qml created 644 +37 0

@@ -0,0 +1,37
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	import QtQuick 1.0
	22
	23	Item {
	24	id: container
	25	width: 400
	26	height: 300
	27	Component.onCompleted: {
	28	var co = Qt.createComponent("main.qml")
	29	if (co.status == Component.Ready) {
	30	var o = co.createObject(container)
	31	} else {
	32	console.log(co.errorString())
	33	console.log("QtCommercial.Chart 1.3 not available")
	34	console.log("Please use correct QML_IMPORT_PATH export")
	35	}
	36	}
	37	}

demos/qmlpolarchart/qml/qmlpolarchart/main.qml created 644 +90 0

@@ -0,0 +1,90
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	import QtQuick 1.0
	22
	23	Rectangle {
	24	width: parent.width
	25	height: parent.height
	26	property int viewNumber: 1
	27	property int viewCount: 3
	28
	29	Loader {
	30	id: loader
	31	anchors.fill: parent
	32	source: "View" + viewNumber + ".qml";
	33	}
	34
	35	Rectangle {
	36	id: infoText
	37	anchors.centerIn: parent
	38	width: parent.width
	39	height: 40
	40	color: "black"
	41	Text {
	42	color: "white"
	43	anchors.centerIn: parent
	44	text: "Use left and right arrow keys to navigate"
	45	}
	46
	47	Behavior on opacity {
	48	NumberAnimation { duration: 400 }
	49	}
	50	}
	51
	52	MouseArea {
	53	focus: true
	54	anchors.fill: parent
	55	onClicked: {
	56	if (infoText.opacity > 0) {
	57	infoText.opacity = 0.0;
	58	} else {
	59	nextView();
	60	}
	61	}
	62	Keys.onPressed: {
	63	if (infoText.opacity > 0) {
	64	infoText.opacity = 0.0;
	65	} else {
	66	if (event.key == Qt.Key_Left) {
	67	previousView();
	68	} else {
	69	nextView();
	70	}
	71	}
	72	}
	73	}
	74
	75	function nextView() {
	76	var i = viewNumber + 1;
	77	if (i > viewCount)
	78	viewNumber = 1;
	79	else
	80	viewNumber = i;
	81	}
	82
	83	function previousView() {
	84	var i = viewNumber - 1;
	85	if (i <= 0)
	86	viewNumber = viewCount;
	87	else
	88	viewNumber = i;
	89	}
	90	}

demos/qmlpolarchart/qmlapplicationviewer/qmlapplicationviewer.cpp created 644 +177 0

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

demos/qmlpolarchart/qmlapplicationviewer/qmlapplicationviewer.h created 644 +46 0

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

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

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

demos/qmlpolarchart/qmlpolarchart.pro created 644 +9 0

@@ -0,0 +1,9
	1	!include( ../demos.pri ) {
	2	error( "Couldn't find the demos.pri file!" )
	3	}
	4
	5	RESOURCES += resources.qrc
	6	SOURCES += main.cpp
	7	OTHER_FILES += qml/qmlpolarchart/*
	8
	9	include(qmlapplicationviewer/qmlapplicationviewer.pri)

demos/qmlpolarchart/resources.qrc created 644 +9 0

@@ -0,0 +1,9
	1	<RCC>
	2	<qresource prefix="/">
	3	<file>qml/qmlpolarchart/loader.qml</file>
	4	<file>qml/qmlpolarchart/main.qml</file>
	5	<file>qml/qmlpolarchart/View1.qml</file>
	6	<file>qml/qmlpolarchart/View2.qml</file>
	7	<file>qml/qmlpolarchart/View3.qml</file>
	8	</qresource>
	9	</RCC>

doc/images/demos_qmlpolarchart1.png created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

doc/images/demos_qmlpolarchart2.png created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

doc/images/demos_qmlpolarchart3.png created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

doc/images/examples_polarchart.png created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

doc/src/demos-qmlpolarchart.qdoc created 644 +33 0

@@ -0,0 +1,33
	1	/*!
	2	\example demos/qmlpolarchart
	3	\title Qml Polar Chart
	4	\subtitle
	5
	6	This is a demonstration of how to use polar chart in your QML application.
	7
	8	\table
	9	\row
	10	\o \br
	11	We begin with a chart that has a spline series and a scatter series with random
	12	data. Both series use the same axes.
	13	\br
	14	\br
	15	\snippet ../demos/qmlpolarchart/qml/qmlpolarchart/View1.qml 1
	16	\o \inlineimage demos_qmlpolarchart1.png
	17	\row
	18	\o \br
	19	The next example shows a chart with some accurate historical data that makes us to use a DateTimeAxis
	20	and AreaSeries.
	21	\br
	22	\br
	23	\snippet ../demos/qmlpolarchart/qml/qmlpolarchart/View2.qml 1
	24	\o \inlineimage demos_qmlpolarchart2.png
	25	\row
	26	\o \br
	27	And the final example with a chart that uses a CategoryAxis to make the data easier to understand.
	28	\br
	29	\br
	30	\snippet ../demos/qmlpolarchart/qml/qmlpolarchart/View3.qml 1
	31	\o \inlineimage demos_qmlpolarchart3.png
	32	\endtable
	33	*/

doc/src/examples-polarchart.qdoc created 644 +33 0

@@ -0,0 +1,33
	1	/*!
	2	\example examples/polarchart
	3	\title Polar chart example
	4	\subtitle
	5
	6	The example shows how to create simple polar chart with multiple different series.
	7	It also shows how to implement scrolling and zooming of the polar chart as well as
	8	visually demonstrate how polar chart and cartesian chart relate to each other.
	9
	10	\image examples_polarchart.png
	11
	12	Creating polar chart is done via QPolarChart instance instead of QChart.
	13
	14	\snippet ../examples/polarchart/main.cpp 1
	15
	16	Axes are created similarly to cartesian charts, but when axes are added to the chart,
	17	you can use polar orientations instead of alignments.
	18
	19	\snippet ../examples/polarchart/main.cpp 2
	20
	21	Zooming and scrolling of the polar chart is logically nearly identical to zooming and scrolling of cartesian chart.
	22	The main difference is that when scrolling along X-axis (angular axis), angle is used instead of number of pixels.
	23	Another difference is that zooming to a rectangle cannot be done.
	24
	25	\snippet ../examples/polarchart/chartview.cpp 1
	26
	27	Same axes and series can be used in both cartesian and polar charts, though not simultaneously.
	28	To switch between chart types, you need to first remove series and axes from the old chart and then add
	29	them to the new chart. If you want to preserve axis ranges, those need to be copied, too.
	30
	31	\snippet ../examples/polarchart/chartview.cpp 2
	32
	33	*/

examples/polarchart/chartview.cpp created 644 +111 0

@@ -0,0 +1,111
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "chartview.h"
	22	#include <QMouseEvent>
	23	#include <QDebug>
	24	#include <QAbstractAxis>
	25	#include <QValueAxis>
	26
	27	QTCOMMERCIALCHART_USE_NAMESPACE
	28
	29	ChartView::ChartView(QWidget *parent)
	30	: QChartView(parent)
	31	{
	32	}
	33
	34	//![1]
	35	void ChartView::keyPressEvent(QKeyEvent *event)
	36	{
	37	switch (event->key()) {
	38	case Qt::Key_Plus:
	39	chart()->zoomIn();
	40	break;
	41	case Qt::Key_Minus:
	42	chart()->zoomOut();
	43	break;
	44	case Qt::Key_Left:
	45	chart()->scroll(-1.0, 0);
	46	break;
	47	case Qt::Key_Right:
	48	chart()->scroll(1.0, 0);
	49	break;
	50	case Qt::Key_Up:
	51	chart()->scroll(0, 1.0);
	52	break;
	53	case Qt::Key_Down:
	54	chart()->scroll(0, -1.0);
	55	break;
	56	case Qt::Key_Space:
	57	switchChartType();
	58	break;
	59	default:
	60	QGraphicsView::keyPressEvent(event);
	61	break;
	62	}
	63	}
	64	//![1]
	65
	66	//![2]
	67	void ChartView::switchChartType()
	68	{
	69	QChart *newChart;
	70	QChart *oldChart = chart();
	71
	72	if (oldChart->chartType() == QChart::ChartTypeCartesian)
	73	newChart = new QPolarChart();
	74	else
	75	newChart = new QChart();
	76
	77	// Move series and axes from old chart to new one
	78	QList<QAbstractSeries *> seriesList = oldChart->series();
	79	QList<QAbstractAxis *> axisList = oldChart->axes();
	80	QList<QPair<qreal, qreal>> axisRanges;
	81
	82	foreach (QAbstractAxis *axis, axisList) {
	83	QValueAxis valueAxis = static_cast<QValueAxis >(axis);
	84	axisRanges.append(QPair<qreal, qreal>(valueAxis->min(), valueAxis->max()));
	85	}
	86
	87	foreach (QAbstractSeries *series, seriesList)
	88	oldChart->removeSeries(series);
	89
	90	foreach (QAbstractAxis *axis, axisList) {
	91	oldChart->removeAxis(axis);
	92	newChart->addAxis(axis, axis->alignment());
	93	}
	94
	95	foreach (QAbstractSeries *series, seriesList) {
	96	newChart->addSeries(series);
	97	foreach (QAbstractAxis *axis, axisList)
	98	series->attachAxis(axis);
	99	}
	100
	101	int count = 0;
	102	foreach (QAbstractAxis *axis, axisList) {
	103	axis->setRange(axisRanges[count].first, axisRanges[count].second);
	104	count++;
	105	}
	106
	107	newChart->setTitle(oldChart->title());
	108	setChart(newChart);
	109	delete oldChart;
	110	}
	111	//![2]

examples/polarchart/chartview.h created 644 +41 0

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

examples/polarchart/main.cpp created 644 +137 0

@@ -0,0 +1,137
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "chartview.h"
	22	#include <QApplication>
	23	#include <QMainWindow>
	24	#include <QScatterSeries>
	25	#include <QLineSeries>
	26	#include <QSplineSeries>
	27	#include <QAreaSeries>
	28	#include <QValueAxis>
	29	#include <QPolarChart>
	30	#include <QDebug>
	31
	32	QTCOMMERCIALCHART_USE_NAMESPACE
	33
	34	int main(int argc, char *argv[])
	35	{
	36	QApplication a(argc, argv);
	37
	38	const qreal angularMin = -100;
	39	const qreal angularMax = 100;
	40
	41	const qreal radialMin = -100;
	42	const qreal radialMax = 100;
	43
	44	QScatterSeries *series1 = new QScatterSeries();
	45	series1->setName("scatter");
	46	for (int i = angularMin; i <= angularMax; i += 10)
	47	series1->append(i, (i / radialMax) * radialMax + 8.0);
	48
	49	QSplineSeries *series2 = new QSplineSeries();
	50	series2->setName("spline");
	51	for (int i = angularMin; i <= angularMax; i += 10)
	52	series2->append(i, (i / radialMax) * radialMax);
	53
	54	QLineSeries *series3 = new QLineSeries();
	55	series3->setName("star outer");
	56	qreal ad = (angularMax - angularMin) / 8;
	57	qreal rd = (radialMax - radialMin) / 3 * 1.3;
	58	series3->append(angularMin, radialMax);
	59	series3->append(angularMin + ad*1, radialMin + rd);
	60	series3->append(angularMin + ad*2, radialMax);
	61	series3->append(angularMin + ad*3, radialMin + rd);
	62	series3->append(angularMin + ad*4, radialMax);
	63	series3->append(angularMin + ad*5, radialMin + rd);
	64	series3->append(angularMin + ad*6, radialMax);
	65	series3->append(angularMin + ad*7, radialMin + rd);
	66	series3->append(angularMin + ad*8, radialMax);
	67
	68	QLineSeries *series4 = new QLineSeries();
	69	series4->setName("star inner");
	70	ad = (angularMax - angularMin) / 8;
	71	rd = (radialMax - radialMin) / 3;
	72	series4->append(angularMin, radialMax);
	73	series4->append(angularMin + ad*1, radialMin + rd);
	74	series4->append(angularMin + ad*2, radialMax);
	75	series4->append(angularMin + ad*3, radialMin + rd);
	76	series4->append(angularMin + ad*4, radialMax);
	77	series4->append(angularMin + ad*5, radialMin + rd);
	78	series4->append(angularMin + ad*6, radialMax);
	79	series4->append(angularMin + ad*7, radialMin + rd);
	80	series4->append(angularMin + ad*8, radialMax);
	81
	82	QAreaSeries *series5 = new QAreaSeries();
	83	series5->setName("star area");
	84	series5->setUpperSeries(series3);
	85	series5->setLowerSeries(series4);
	86	series5->setOpacity(0.5);
	87
	88	//![1]
	89	QPolarChart *chart = new QPolarChart();
	90	//![1]
	91	chart->addSeries(series1);
	92	chart->addSeries(series2);
	93	chart->addSeries(series3);
	94	chart->addSeries(series4);
	95	chart->addSeries(series5);
	96
	97	chart->setTitle("Use arrow keys to scroll, +/- to zoom, and space to switch chart type.");
	98
	99	//![2]
	100	QValueAxis *angularAxis = new QValueAxis();
	101	angularAxis->setTickCount(9); // First and last ticks are co-located on 0/360 angle.
	102	angularAxis->setLabelFormat("%.1f");
	103	angularAxis->setShadesVisible(true);
	104	angularAxis->setShadesBrush(QBrush(QColor(249, 249, 255)));
	105	chart->addAxis(angularAxis, QPolarChart::PolarOrientationAngular);
	106
	107	QValueAxis *radialAxis = new QValueAxis();
	108	radialAxis->setTickCount(9);
	109	radialAxis->setLabelFormat("%d");
	110	chart->addAxis(radialAxis, QPolarChart::PolarOrientationRadial);
	111	//![2]
	112
	113	series1->attachAxis(radialAxis);
	114	series1->attachAxis(angularAxis);
	115	series2->attachAxis(radialAxis);
	116	series2->attachAxis(angularAxis);
	117	series3->attachAxis(radialAxis);
	118	series3->attachAxis(angularAxis);
	119	series4->attachAxis(radialAxis);
	120	series4->attachAxis(angularAxis);
	121	series5->attachAxis(radialAxis);
	122	series5->attachAxis(angularAxis);
	123
	124	radialAxis->setRange(radialMin, radialMax);
	125	angularAxis->setRange(angularMin, angularMax);
	126
	127	ChartView *chartView = new ChartView();
	128	chartView->setChart(chart);
	129	chartView->setRenderHint(QPainter::Antialiasing);
	130
	131	QMainWindow window;
	132	window.setCentralWidget(chartView);
	133	window.resize(800, 600);
	134	window.show();
	135
	136	return a.exec();
	137	}

examples/polarchart/polarchart.pro created 644 +6 0

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

plugins/declarative/declarativepolarchart.cpp created 644 +64 0

@@ -0,0 +1,64
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "declarativepolarchart.h"
	22	#include "qchart.h"
	23
	24	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	25
	26	/*!
	27	\qmlclass PolarChartView DeclarativePolarChart
	28
	29	PolarChartView element is the parent that is responsible for showing different chart series types
	30	in a polar chart.
	31
	32	Polar charts support line, spline, area, and scatter series, and all axis types
	33	supported by those series.
	34
	35	\note When setting ticks to an angular ValueAxis, keep in mind that the first and last tick
	36	are co-located at 0/360 degree angle.
	37
	38	\note If the angular distance between two consecutive points in a series is more than 180 degrees,
	39	any line connecting the two points becomes meaningless, so choose the axis ranges accordingly
	40	when displaying line, spline, or area series.
	41
	42	\note Polar charts do not support multiple axes of same orientation.
	43
	44	The following QML shows how to create a polar chart with two series:
	45	\snippet ../demos/qmlpolarchart/qml/qmlpolarchart/view1.qml 1
	46
	47	\beginfloatleft
	48	\image demos_qmlpolarchart1.png
	49	\endfloat
	50	\clearfloat
	51	*/
	52
	53	DeclarativePolarChart::DeclarativePolarChart(QDeclarativeItem *parent)
	54	: DeclarativeChart(QChart::ChartTypePolar, parent)
	55	{
	56	}
	57
	58	DeclarativePolarChart::~DeclarativePolarChart()
	59	{
	60	}
	61
	62	#include "moc_declarativepolarchart.cpp"
	63
	64	QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativepolarchart.h created 644 +40 0

@@ -0,0 +1,40
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#ifndef DECLARATIVEPOLARCHART_H
	22	#define DECLARATIVEPOLARCHART_H
	23
	24	#include <QtCore/QtGlobal>
	25	#include <QtDeclarative/QDeclarativeItem>
	26	#include "declarativechart.h"
	27
	28	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	29
	30	class DeclarativePolarChart : public DeclarativeChart
	31	{
	32	Q_OBJECT
	33	public:
	34	DeclarativePolarChart(QDeclarativeItem *parent = 0);
	35	~DeclarativePolarChart();
	36	};
	37
	38	QTCOMMERCIALCHART_END_NAMESPACE
	39
	40	#endif // DECLARATIVEPOLARCHART_H

src/axis/cartesianchartaxis.cpp created 644 +197 0

@@ -0,0 +1,197
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "cartesianchartaxis_p.h"
	22	#include "qabstractaxis.h"
	23	#include "qabstractaxis_p.h"
	24	#include "chartpresenter_p.h"
	25	#include "abstractchartlayout_p.h"
	26	#include "abstractdomain_p.h"
	27	#include "linearrowitem_p.h"
	28	#include <QValueAxis>
	29	#include <QLogValueAxis>
	30	#include <QGraphicsLayout>
	31
	32	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	33
	34	CartesianChartAxis::CartesianChartAxis(QAbstractAxis axis, QGraphicsItem item , bool intervalAxis)
	35	: ChartAxisElement(axis, item, intervalAxis)
	36	{
	37	Q_ASSERT(item);
	38	}
	39
	40
	41	CartesianChartAxis::~CartesianChartAxis()
	42	{
	43	}
	44
	45	void CartesianChartAxis::createItems(int count)
	46	{
	47	if (arrowItems().size() == 0) {
	48	QGraphicsLineItem *arrow = new LineArrowItem(this, this);
	49	arrow->setPen(axis()->linePen());
	50	arrowGroup()->addToGroup(arrow);
	51	}
	52
	53	if (intervalAxis() && gridItems().size() == 0) {
	54	for (int i = 0 ; i < 2 ; i ++){
	55	QGraphicsLineItem *item = new QGraphicsLineItem(this);
	56	item->setPen(axis()->gridLinePen());
	57	gridGroup()->addToGroup(item);
	58	}
	59	}
	60
	61	for (int i = 0; i < count; ++i) {
	62	QGraphicsLineItem *arrow = new QGraphicsLineItem(this);
	63	QGraphicsLineItem *grid = new QGraphicsLineItem(this);
	64	QGraphicsSimpleTextItem *label = new QGraphicsSimpleTextItem(this);
	65	QGraphicsSimpleTextItem *title = titleItem();
	66	arrow->setPen(axis()->linePen());
	67	grid->setPen(axis()->gridLinePen());
	68	label->setFont(axis()->labelsFont());
	69	label->setPen(axis()->labelsPen());
	70	label->setBrush(axis()->labelsBrush());
	71	label->setRotation(axis()->labelsAngle());
	72	title->setFont(axis()->titleFont());
	73	title->setPen(axis()->titlePen());
	74	title->setBrush(axis()->titleBrush());
	75	title->setText(axis()->titleText());
	76	arrowGroup()->addToGroup(arrow);
	77	gridGroup()->addToGroup(grid);
	78	labelGroup()->addToGroup(label);
	79
	80	if ((gridItems().size()) % 2 && gridItems().size() > 2) {
	81	QGraphicsRectItem* shades = new QGraphicsRectItem(this);
	82	shades->setPen(axis()->shadesPen());
	83	shades->setBrush(axis()->shadesBrush());
	84	shadeGroup()->addToGroup(shades);
	85	}
	86	}
	87
	88	}
	89
	90	void CartesianChartAxis::deleteItems(int count)
	91	{
	92	QList<QGraphicsItem *> lines = gridItems();
	93	QList<QGraphicsItem *> labels = labelItems();
	94	QList<QGraphicsItem *> shades = shadeItems();
	95	QList<QGraphicsItem *> axis = arrowItems();
	96
	97	for (int i = 0; i < count; ++i) {
	98	if (lines.size() % 2 && lines.size() > 1)
	99	delete(shades.takeLast());
	100	delete(lines.takeLast());
	101	delete(labels.takeLast());
	102	delete(axis.takeLast());
	103	}
	104	}
	105
	106	void CartesianChartAxis::updateLayout(QVector<qreal> &layout)
	107	{
	108	int diff = ChartAxisElement::layout().size() - layout.size();
	109
	110	if (diff > 0)
	111	deleteItems(diff);
	112	else if (diff < 0)
	113	createItems(-diff);
	114
	115	if (animation()) {
	116	switch (presenter()->state()) {
	117	case ChartPresenter::ZoomInState:
	118	animation()->setAnimationType(AxisAnimation::ZoomInAnimation);
	119	animation()->setAnimationPoint(presenter()->statePoint());
	120	break;
	121	case ChartPresenter::ZoomOutState:
	122	animation()->setAnimationType(AxisAnimation::ZoomOutAnimation);
	123	animation()->setAnimationPoint(presenter()->statePoint());
	124	break;
	125	case ChartPresenter::ScrollUpState:
	126	case ChartPresenter::ScrollLeftState:
	127	animation()->setAnimationType(AxisAnimation::MoveBackwordAnimation);
	128	break;
	129	case ChartPresenter::ScrollDownState:
	130	case ChartPresenter::ScrollRightState:
	131	animation()->setAnimationType(AxisAnimation::MoveForwardAnimation);
	132	break;
	133	case ChartPresenter::ShowState:
	134	animation()->setAnimationType(AxisAnimation::DefaultAnimation);
	135	break;
	136	}
	137	animation()->setValues(ChartAxisElement::layout(), layout);
	138	presenter()->startAnimation(animation());
	139	} else {
	140	setLayout(layout);
	141	updateGeometry();
	142	}
	143	}
	144
	145	bool CartesianChartAxis::isEmpty()
	146	{
	147	return axisGeometry().isEmpty()
	148	\|\| gridGeometry().isEmpty()
	149	\|\| qFuzzyCompare(min(), max());
	150	}
	151
	152	void CartesianChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
	153	{
	154	m_gridRect = grid;
	155	setAxisGeometry(axis);
	156
	157	if (isEmpty())
	158	return;
	159
	160	QVector<qreal> layout = calculateLayout();
	161	updateLayout(layout);
	162	}
	163
	164	QSizeF CartesianChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
	165	{
	166	Q_UNUSED(which);
	167	Q_UNUSED(constraint);
	168	return QSizeF();
	169	}
	170
	171	void CartesianChartAxis::handleArrowPenChanged(const QPen &pen)
	172	{
	173	foreach (QGraphicsItem *item, arrowItems())
	174	static_cast<QGraphicsLineItem *>(item)->setPen(pen);
	175	}
	176
	177	void CartesianChartAxis::handleGridPenChanged(const QPen &pen)
	178	{
	179	foreach (QGraphicsItem *item, gridItems())
	180	static_cast<QGraphicsLineItem *>(item)->setPen(pen);
	181	}
	182
	183	void CartesianChartAxis::handleShadesBrushChanged(const QBrush &brush)
	184	{
	185	foreach (QGraphicsItem *item, shadeItems())
	186	static_cast<QGraphicsRectItem *>(item)->setBrush(brush);
	187	}
	188
	189	void CartesianChartAxis::handleShadesPenChanged(const QPen &pen)
	190	{
	191	foreach (QGraphicsItem *item, shadeItems())
	192	static_cast<QGraphicsRectItem *>(item)->setPen(pen);
	193	}
	194
	195	#include "moc_cartesianchartaxis_p.cpp"
	196
	197	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/cartesianchartaxis_p.h created 644 +79 0

@@ -0,0 +1,79
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef CARTESIANCHARTAXIS_H
	31	#define CARTESIANCHARTAXIS_H
	32
	33	#include "qchartglobal.h"
	34	#include "chartaxiselement_p.h"
	35
	36	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	37
	38	class QAbstractAxis;
	39
	40	class CartesianChartAxis : public ChartAxisElement
	41	{
	42	Q_OBJECT
	43	Q_INTERFACES(QGraphicsLayoutItem)
	44	public:
	45
	46	CartesianChartAxis(QAbstractAxis axis, QGraphicsItem item = 0, bool intervalAxis = false);
	47	~CartesianChartAxis();
	48
	49	void setGeometry(const QRectF &axis, const QRectF &grid);
	50	QRectF gridGeometry() const { return m_gridRect; }
	51	bool isEmpty();
	52
	53	virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
	54
	55	protected:
	56	void setGeometry(const QRectF &size) { Q_UNUSED(size);}
	57	virtual void updateGeometry() = 0;
	58	void updateLayout(QVector<qreal> &layout);
	59
	60	public Q_SLOTS:
	61	virtual void handleArrowPenChanged(const QPen &pen);
	62	virtual void handleGridPenChanged(const QPen &pen);
	63	virtual void handleShadesBrushChanged(const QBrush &brush);
	64	virtual void handleShadesPenChanged(const QPen &pen);
	65
	66	private:
	67	void createItems(int count);
	68	void deleteItems(int count);
	69
	70	private:
	71	QRectF m_gridRect;
	72
	73	friend class AxisAnimation;
	74	friend class LineArrowItem;
	75	};
	76
	77	QTCOMMERCIALCHART_END_NAMESPACE
	78
	79	#endif /* CARTESIANCHARTAXIS_H */

src/axis/categoryaxis/polarchartcategoryaxisangular.cpp created 644 +80 0

@@ -0,0 +1,80
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "polarchartcategoryaxisangular_p.h"
	22	#include "chartpresenter_p.h"
	23	#include "abstractchartlayout_p.h"
	24	#include "qcategoryaxis.h"
	25	#include <QDebug>
	26
	27	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	28
	29	PolarChartCategoryAxisAngular::PolarChartCategoryAxisAngular(QCategoryAxis axis, QGraphicsItem item)
	30	: PolarChartAxisAngular(axis, item, true)
	31	{
	32	QObject::connect(axis, SIGNAL(categoriesChanged()), this, SLOT(handleCategoriesChanged()));
	33	}
	34
	35	PolarChartCategoryAxisAngular::~PolarChartCategoryAxisAngular()
	36	{
	37	}
	38
	39	QVector<qreal> PolarChartCategoryAxisAngular::calculateLayout() const
	40	{
	41	QCategoryAxis catAxis = static_cast<QCategoryAxis >(axis());
	42	int tickCount = catAxis->categoriesLabels().count() + 1;
	43	QVector<qreal> points;
	44
	45	if (tickCount < 2)
	46	return points;
	47
	48	qreal range = max() - min();
	49	if (range > 0) {
	50	points.resize(tickCount);
	51	qreal scale = 360.0 / range;
	52	qreal angle;
	53	for (int i = 0; i < tickCount; ++i) {
	54	if (i < tickCount - 1)
	55	angle = (catAxis->startValue(catAxis->categoriesLabels().at(i)) - min()) * scale;
	56	else
	57	angle = (catAxis->endValue(catAxis->categoriesLabels().at(i - 1)) - min()) * scale;
	58	points[i] = angle;
	59	}
	60	}
	61
	62	return points;
	63	}
	64
	65	void PolarChartCategoryAxisAngular::createAxisLabels(const QVector<qreal> &layout)
	66	{
	67	Q_UNUSED(layout);
	68	setLabels(static_cast<QCategoryAxis *>(axis())->categoriesLabels() << "");
	69	}
	70
	71	void PolarChartCategoryAxisAngular::handleCategoriesChanged()
	72	{
	73	QGraphicsLayoutItem::updateGeometry();
	74	presenter()->layout()->invalidate();
	75	}
	76
	77
	78	#include "moc_polarchartcategoryaxisangular_p.cpp"
	79
	80	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoryaxis/polarchartcategoryaxisangular_p.h created 644 +56 0

@@ -0,0 +1,56
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef POLARCHARTCATEGORYAXISANGULAR_P_H
	31	#define POLARCHARTCATEGORYAXISANGULAR_P_H
	32
	33	#include "polarchartaxisangular_p.h"
	34
	35	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	36
	37	class QCategoryAxis;
	38
	39	class PolarChartCategoryAxisAngular : public PolarChartAxisAngular
	40	{
	41	Q_OBJECT
	42
	43	public:
	44	PolarChartCategoryAxisAngular(QCategoryAxis axis, QGraphicsItem item);
	45	~PolarChartCategoryAxisAngular();
	46
	47	virtual QVector<qreal> calculateLayout() const;
	48	virtual void createAxisLabels(const QVector<qreal> &layout);
	49
	50	public Q_SLOTS:
	51	void handleCategoriesChanged();
	52	};
	53
	54	QTCOMMERCIALCHART_END_NAMESPACE
	55
	56	#endif // POLARCHARTCATEGORYAXISANGULAR_P_H

src/axis/categoryaxis/polarchartcategoryaxisradial.cpp created 644 +79 0

@@ -0,0 +1,79
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "polarchartcategoryaxisradial_p.h"
	22	#include "chartpresenter_p.h"
	23	#include "abstractchartlayout_p.h"
	24	#include "qcategoryaxis.h"
	25	#include <QDebug>
	26
	27	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	28
	29	PolarChartCategoryAxisRadial::PolarChartCategoryAxisRadial(QCategoryAxis axis, QGraphicsItem item)
	30	: PolarChartAxisRadial(axis, item, true)
	31	{
	32	QObject::connect(axis, SIGNAL(categoriesChanged()), this, SLOT(handleCategoriesChanged()));
	33	}
	34
	35	PolarChartCategoryAxisRadial::~PolarChartCategoryAxisRadial()
	36	{
	37	}
	38
	39	QVector<qreal> PolarChartCategoryAxisRadial::calculateLayout() const
	40	{
	41	QCategoryAxis catAxis = static_cast<QCategoryAxis >(axis());
	42	int tickCount = catAxis->categoriesLabels().count() + 1;
	43	QVector<qreal> points;
	44
	45	if (tickCount < 2)
	46	return points;
	47
	48	qreal range = max() - min();
	49	if (range > 0) {
	50	points.resize(tickCount);
	51	qreal scale = (axisGeometry().width() / 2) / range;
	52	qreal angle;
	53	for (int i = 0; i < tickCount; ++i) {
	54	if (i < tickCount - 1)
	55	angle = (catAxis->startValue(catAxis->categoriesLabels().at(i)) - min()) * scale;
	56	else
	57	angle = (catAxis->endValue(catAxis->categoriesLabels().at(i - 1)) - min()) * scale;
	58	points[i] = angle;
	59	}
	60	}
	61
	62	return points;
	63	}
	64
	65	void PolarChartCategoryAxisRadial::createAxisLabels(const QVector<qreal> &layout)
	66	{
	67	Q_UNUSED(layout);
	68	setLabels(static_cast<QCategoryAxis *>(axis())->categoriesLabels() << "");
	69	}
	70
	71	void PolarChartCategoryAxisRadial::handleCategoriesChanged()
	72	{
	73	QGraphicsLayoutItem::updateGeometry();
	74	presenter()->layout()->invalidate();
	75	}
	76
	77	#include "moc_polarchartcategoryaxisradial_p.cpp"
	78
	79	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoryaxis/polarchartcategoryaxisradial_p.h created 644 +56 0

@@ -0,0 +1,56
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef POLARCHARTCATEGORYAXISRADIAL_P_H
	31	#define POLARCHARTCATEGORYAXISRADIAL_P_H
	32
	33	#include "polarchartaxisradial_p.h"
	34
	35	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	36
	37	class QCategoryAxis;
	38
	39	class PolarChartCategoryAxisRadial : public PolarChartAxisRadial
	40	{
	41	Q_OBJECT
	42
	43	public:
	44	PolarChartCategoryAxisRadial(QCategoryAxis axis, QGraphicsItem item);
	45	~PolarChartCategoryAxisRadial();
	46
	47	virtual QVector<qreal> calculateLayout() const;
	48	virtual void createAxisLabels(const QVector<qreal> &layout);
	49
	50	public Q_SLOTS:
	51	void handleCategoriesChanged();
	52	};
	53
	54	QTCOMMERCIALCHART_END_NAMESPACE
	55
	56	#endif // POLARCHARTCATEGORYAXISRADIAL_P_H

src/axis/chartaxiselement.cpp created 644 +349 0

@@ -0,0 +1,349
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "chartaxiselement_p.h"
	22	#include "qabstractaxis_p.h"
	23	#include "chartpresenter_p.h"
	24	#include "abstractchartlayout_p.h"
	25	#include <qmath.h>
	26	#include <QDateTime>
	27	#include <QFontMetrics>
	28
	29	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	30
	31	ChartAxisElement::ChartAxisElement(QAbstractAxis axis, QGraphicsItem item, bool intervalAxis)
	32	: ChartElement(item),
	33	m_axis(axis),
	34	m_animation(0),
	35	m_grid(new QGraphicsItemGroup(item)),
	36	m_arrow(new QGraphicsItemGroup(item)),
	37	m_shades(new QGraphicsItemGroup(item)),
	38	m_labels(new QGraphicsItemGroup(item)),
	39	m_title(new QGraphicsSimpleTextItem(item)),
	40	m_intervalAxis(intervalAxis)
	41
	42	{
	43	//initial initialization
	44	m_arrow->setHandlesChildEvents(false);
	45	m_arrow->setZValue(ChartPresenter::AxisZValue);
	46	m_labels->setZValue(ChartPresenter::AxisZValue);
	47	m_shades->setZValue(ChartPresenter::ShadesZValue);
	48	m_grid->setZValue(ChartPresenter::GridZValue);
	49	m_title->setZValue(ChartPresenter::GridZValue);
	50	handleVisibleChanged(axis->isVisible());
	51	connectSlots();
	52
	53	setFlag(QGraphicsItem::ItemHasNoContents, true);
	54	}
	55
	56	ChartAxisElement::~ChartAxisElement()
	57	{
	58	}
	59
	60	void ChartAxisElement::connectSlots()
	61	{
	62	QObject::connect(axis(), SIGNAL(visibleChanged(bool)), this, SLOT(handleVisibleChanged(bool)));
	63	QObject::connect(axis(), SIGNAL(lineVisibleChanged(bool)), this, SLOT(handleArrowVisibleChanged(bool)));
	64	QObject::connect(axis(), SIGNAL(gridVisibleChanged(bool)), this, SLOT(handleGridVisibleChanged(bool)));
	65	QObject::connect(axis(), SIGNAL(labelsVisibleChanged(bool)), this, SLOT(handleLabelsVisibleChanged(bool)));
	66	QObject::connect(axis(), SIGNAL(shadesVisibleChanged(bool)), this, SLOT(handleShadesVisibleChanged(bool)));
	67	QObject::connect(axis(), SIGNAL(labelsAngleChanged(int)), this, SLOT(handleLabelsAngleChanged(int)));
	68	QObject::connect(axis(), SIGNAL(linePenChanged(const QPen&)), this, SLOT(handleArrowPenChanged(const QPen&)));
	69	QObject::connect(axis(), SIGNAL(labelsPenChanged(const QPen&)), this, SLOT(handleLabelsPenChanged(const QPen&)));
	70	QObject::connect(axis(), SIGNAL(labelsBrushChanged(const QBrush&)), this, SLOT(handleLabelsBrushChanged(const QBrush&)));
	71	QObject::connect(axis(), SIGNAL(labelsFontChanged(const QFont&)), this, SLOT(handleLabelsFontChanged(const QFont&)));
	72	QObject::connect(axis(), SIGNAL(gridLinePenChanged(const QPen&)), this, SLOT(handleGridPenChanged(const QPen&)));
	73	QObject::connect(axis(), SIGNAL(shadesPenChanged(const QPen&)), this, SLOT(handleShadesPenChanged(const QPen&)));
	74	QObject::connect(axis(), SIGNAL(shadesBrushChanged(const QBrush&)), this, SLOT(handleShadesBrushChanged(const QBrush&)));
	75	QObject::connect(axis(), SIGNAL(titleTextChanged(const QString&)), this, SLOT(handleTitleTextChanged(const QString&)));
	76	QObject::connect(axis(), SIGNAL(titleFontChanged(const QFont&)), this, SLOT(handleTitleFontChanged(const QFont&)));
	77	QObject::connect(axis(), SIGNAL(titlePenChanged(const QPen&)), this, SLOT(handleTitlePenChanged(const QPen&)));
	78	QObject::connect(axis(), SIGNAL(titleBrushChanged(const QBrush&)), this, SLOT(handleTitleBrushChanged(const QBrush&)));
	79	QObject::connect(axis(), SIGNAL(titleVisibleChanged(bool)), this, SLOT(handleTitleVisibleChanged(bool)));
	80	QObject::connect(axis()->d_ptr.data(), SIGNAL(rangeChanged(qreal, qreal)), this, SLOT(handleRangeChanged(qreal, qreal)));
	81	}
	82
	83	void ChartAxisElement::handleArrowVisibleChanged(bool visible)
	84	{
	85	m_arrow->setVisible(visible);
	86	}
	87
	88	void ChartAxisElement::handleGridVisibleChanged(bool visible)
	89	{
	90	m_grid->setVisible(visible);
	91	}
	92
	93	void ChartAxisElement::handleLabelsVisibleChanged(bool visible)
	94	{
	95	QGraphicsLayoutItem::updateGeometry();
	96	presenter()->layout()->invalidate();
	97	m_labels->setVisible(visible);
	98	}
	99
	100	void ChartAxisElement::handleShadesVisibleChanged(bool visible)
	101	{
	102	m_shades->setVisible(visible);
	103	}
	104
	105	void ChartAxisElement::handleTitleVisibleChanged(bool visible)
	106	{
	107	QGraphicsLayoutItem::updateGeometry();
	108	presenter()->layout()->invalidate();
	109	m_title->setVisible(visible);
	110	}
	111
	112	void ChartAxisElement::handleLabelsAngleChanged(int angle)
	113	{
	114	foreach (QGraphicsItem *item, m_labels->childItems())
	115	item->setRotation(angle);
	116
	117	QGraphicsLayoutItem::updateGeometry();
	118	presenter()->layout()->invalidate();
	119	}
	120
	121	void ChartAxisElement::handleLabelsPenChanged(const QPen &pen)
	122	{
	123	foreach (QGraphicsItem *item, m_labels->childItems())
	124	static_cast<QGraphicsSimpleTextItem *>(item)->setPen(pen);
	125	}
	126
	127	void ChartAxisElement::handleLabelsBrushChanged(const QBrush &brush)
	128	{
	129	foreach (QGraphicsItem *item, m_labels->childItems())
	130	static_cast<QGraphicsSimpleTextItem *>(item)->setBrush(brush);
	131	}
	132
	133	void ChartAxisElement::handleLabelsFontChanged(const QFont &font)
	134	{
	135	foreach (QGraphicsItem *item, m_labels->childItems())
	136	static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);
	137	QGraphicsLayoutItem::updateGeometry();
	138	presenter()->layout()->invalidate();
	139	}
	140
	141	void ChartAxisElement::handleTitleTextChanged(const QString &title)
	142	{
	143	QGraphicsLayoutItem::updateGeometry();
	144	presenter()->layout()->invalidate();
	145	m_title->setText(title);
	146	}
	147
	148	void ChartAxisElement::handleTitlePenChanged(const QPen &pen)
	149	{
	150	m_title->setPen(pen);
	151	}
	152
	153	void ChartAxisElement::handleTitleBrushChanged(const QBrush &brush)
	154	{
	155	m_title->setBrush(brush);
	156	}
	157
	158	void ChartAxisElement::handleTitleFontChanged(const QFont &font)
	159	{
	160	if (m_title->font() != font) {
	161	m_title->setFont(font);
	162	QGraphicsLayoutItem::updateGeometry();
	163	presenter()->layout()->invalidate();
	164	}
	165	}
	166
	167	void ChartAxisElement::handleVisibleChanged(bool visible)
	168	{
	169	setVisible(visible);
	170	if (!visible) {
	171	m_grid->setVisible(visible);
	172	m_arrow->setVisible(visible);
	173	m_shades->setVisible(visible);
	174	m_labels->setVisible(visible);
	175	m_title->setVisible(visible);
	176	} else {
	177	m_grid->setVisible(axis()->isGridLineVisible());
	178	m_arrow->setVisible(axis()->isLineVisible());
	179	m_shades->setVisible(axis()->shadesVisible());
	180	m_labels->setVisible(axis()->labelsVisible());
	181	m_title->setVisible(axis()->isTitleVisible());
	182	}
	183
	184	if (presenter()) presenter()->layout()->invalidate();
	185	}
	186
	187	QRect ChartAxisElement::labelBoundingRect(const QFontMetrics &fn, const QString &label) const
	188	{
	189	QRect boundingRect = fn.boundingRect(label);
	190	// Take label rotation into account
	191	if (axis()->labelsAngle()) {
	192	QTransform transform;
	193	transform.rotate(axis()->labelsAngle());
	194	boundingRect = transform.mapRect(boundingRect);
	195	}
	196
	197	return boundingRect;
	198	}
	199
	200	void ChartAxisElement::handleRangeChanged(qreal min, qreal max)
	201	{
	202	Q_UNUSED(min);
	203	Q_UNUSED(max);
	204
	205	if (!isEmpty()) {
	206	QVector<qreal> layout = calculateLayout();
	207	updateLayout(layout);
	208	QSizeF before = effectiveSizeHint(Qt::PreferredSize);
	209	QSizeF after = sizeHint(Qt::PreferredSize);
	210
	211	if (before != after) {
	212	QGraphicsLayoutItem::updateGeometry();
	213	// We don't want to call invalidate on layout, since it will change minimum size of
	214	// component, which we would like to avoid since it causes nasty flips when scrolling
	215	// or zooming, instead recalculate layout and use plotArea for extra space.
	216	presenter()->layout()->setGeometry(presenter()->layout()->geometry());
	217	}
	218	}
	219	}
	220
	221	bool ChartAxisElement::isEmpty()
	222	{
	223	return axisGeometry().isEmpty()
	224	\|\| gridGeometry().isEmpty()
	225	\|\| qFuzzyCompare(min(), max());
	226	}
	227
	228	qreal ChartAxisElement::min() const
	229	{
	230	return m_axis->d_ptr->min();
	231	}
	232
	233	qreal ChartAxisElement::max() const
	234	{
	235	return m_axis->d_ptr->max();
	236	}
	237
	238	QStringList ChartAxisElement::createValueLabels(qreal min, qreal max, int ticks, const QString &format)
	239	{
	240	QStringList labels;
	241
	242	if (max <= min \|\| ticks < 1)
	243	return labels;
	244
	245	int n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
	246	n++;
	247
	248	if (format.isNull()) {
	249	for (int i = 0; i < ticks; i++) {
	250	qreal value = min + (i * (max - min) / (ticks - 1));
	251	labels << QString::number(value, 'f', n);
	252	}
	253	} else {
	254	QByteArray array = format.toLatin1();
	255	for (int i = 0; i < ticks; i++) {
	256	qreal value = min + (i * (max - min) / (ticks - 1));
	257	if (format.contains("d")
	258	\|\| format.contains("i")
	259	\|\| format.contains("c")) {
	260	labels << QString().sprintf(array, (qint64)value);
	261	} else if (format.contains("u")
	262	\|\| format.contains("o")
	263	\|\| format.contains("x", Qt::CaseInsensitive)) {
	264	labels << QString().sprintf(array, (quint64)value);
	265	} else if (format.contains("f", Qt::CaseInsensitive)
	266	\|\| format.contains("e", Qt::CaseInsensitive)
	267	\|\| format.contains("g", Qt::CaseInsensitive)) {
	268	labels << QString().sprintf(array, value);
	269	} else {
	270	labels << QString();
	271	}
	272	}
	273	}
	274
	275	return labels;
	276	}
	277
	278	QStringList ChartAxisElement::createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString &format)
	279	{
	280	QStringList labels;
	281
	282	if (max <= min \|\| ticks < 1)
	283	return labels;
	284
	285	int n = 0;
	286	if (ticks > 1)
	287	n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
	288	n++;
	289
	290	int firstTick;
	291	if (base > 1)
	292	firstTick = ceil(log10(min) / log10(base));
	293	else
	294	firstTick = ceil(log10(max) / log10(base));
	295
	296	if (format.isNull()) {
	297	for (int i = firstTick; i < ticks + firstTick; i++) {
	298	qreal value = qPow(base, i);
	299	labels << QString::number(value, 'f', n);
	300	}
	301	} else {
	302	QByteArray array = format.toLatin1();
	303	for (int i = firstTick; i < ticks + firstTick; i++) {
	304	qreal value = qPow(base, i);
	305	if (format.contains("d")
	306	\|\| format.contains("i")
	307	\|\| format.contains("c")) {
	308	labels << QString().sprintf(array, (qint64)value);
	309	} else if (format.contains("u")
	310	\|\| format.contains("o")
	311	\|\| format.contains("x", Qt::CaseInsensitive)) {
	312	labels << QString().sprintf(array, (quint64)value);
	313	} else if (format.contains("f", Qt::CaseInsensitive)
	314	\|\| format.contains("e", Qt::CaseInsensitive)
	315	\|\| format.contains("g", Qt::CaseInsensitive)) {
	316	labels << QString().sprintf(array, value);
	317	} else {
	318	labels << QString();
	319	}
	320	}
	321	}
	322
	323	return labels;
	324	}
	325
	326	QStringList ChartAxisElement::createDateTimeLabels(qreal min, qreal max,int ticks,const QString &format)
	327	{
	328	QStringList labels;
	329
	330	if (max <= min \|\| ticks < 1)
	331	return labels;
	332
	333	int n = qMax(int(-floor(log10((max - min) / (ticks - 1)))), 0);
	334	n++;
	335	for (int i = 0; i < ticks; i++) {
	336	qreal value = min + (i * (max - min) / (ticks - 1));
	337	labels << QDateTime::fromMSecsSinceEpoch(value).toString(format);
	338	}
	339	return labels;
	340	}
	341
	342	void ChartAxisElement::axisSelected()
	343	{
	344	emit clicked();
	345	}
	346
	347	#include "moc_chartaxiselement_p.cpp"
	348
	349	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/datetimeaxis/polarchartdatetimeaxisangular.cpp created 644 +80 0

@@ -0,0 +1,80
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "polarchartdatetimeaxisangular_p.h"
	22	#include "chartpresenter_p.h"
	23	#include "abstractchartlayout_p.h"
	24	#include "qdatetimeaxis.h"
	25
	26	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	27
	28	PolarChartDateTimeAxisAngular::PolarChartDateTimeAxisAngular(QDateTimeAxis axis, QGraphicsItem item)
	29	: PolarChartAxisAngular(axis, item)
	30	{
	31	QObject::connect(axis, SIGNAL(tickCountChanged(int)), this, SLOT(handleTickCountChanged(int)));
	32	QObject::connect(axis, SIGNAL(formatChanged(QString)), this, SLOT(handleFormatChanged(QString)));
	33	}
	34
	35	PolarChartDateTimeAxisAngular::~PolarChartDateTimeAxisAngular()
	36	{
	37	}
	38
	39	QVector<qreal> PolarChartDateTimeAxisAngular::calculateLayout() const
	40	{
	41	int tickCount = static_cast<QDateTimeAxis *>(axis())->tickCount();
	42	Q_ASSERT(tickCount >= 2);
	43
	44	QVector<qreal> points;
	45	points.resize(tickCount);
	46
	47	const qreal d = 360.0 / qreal(tickCount - 1);
	48
	49	for (int i = 0; i < tickCount; ++i) {
	50	qreal angularCoordinate = qreal(i) * d;
	51	points[i] = angularCoordinate;
	52	}
	53
	54	return points;
	55	}
	56	void PolarChartDateTimeAxisAngular::createAxisLabels(const QVector<qreal> &layout)
	57	{
	58	QStringList labelList = createDateTimeLabels(min(), max(), layout.size(), static_cast<QDateTimeAxis *>(axis())->format());
	59	setLabels(labelList);
	60	}
	61
	62	void PolarChartDateTimeAxisAngular::handleTickCountChanged(int tick)
	63	{
	64	Q_UNUSED(tick);
	65	QGraphicsLayoutItem::updateGeometry();
	66	if (presenter())
	67	presenter()->layout()->invalidate();
	68	}
	69
	70	void PolarChartDateTimeAxisAngular::handleFormatChanged(const QString &format)
	71	{
	72	Q_UNUSED(format);
	73	QGraphicsLayoutItem::updateGeometry();
	74	if (presenter())
	75	presenter()->layout()->invalidate();
	76	}
	77
	78	#include "moc_polarchartdatetimeaxisangular_p.cpp"
	79
	80	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/datetimeaxis/polarchartdatetimeaxisangular_p.h created 644 +56 0

@@ -0,0 +1,56
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef POLARCHARTDATETIMEAXISANGULAR_P_H
	31	#define POLARCHARTDATETIMEAXISANGULAR_P_H
	32
	33	#include "polarchartaxisangular_p.h"
	34
	35	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	36
	37	class QDateTimeAxis;
	38
	39	class PolarChartDateTimeAxisAngular : public PolarChartAxisAngular
	40	{
	41	Q_OBJECT
	42	public:
	43	PolarChartDateTimeAxisAngular(QDateTimeAxis axis, QGraphicsItem item);
	44	~PolarChartDateTimeAxisAngular();
	45
	46	virtual QVector<qreal> calculateLayout() const;
	47	virtual void createAxisLabels(const QVector<qreal> &layout);
	48
	49	private Q_SLOTS:
	50	void handleTickCountChanged(int tick);
	51	void handleFormatChanged(const QString &format);
	52	};
	53
	54	QTCOMMERCIALCHART_END_NAMESPACE
	55
	56	#endif // POLARCHARTDATETIMEAXISANGULAR_P_H

src/axis/datetimeaxis/polarchartdatetimeaxisradial.cpp created 644 +79 0

@@ -0,0 +1,79
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "polarchartdatetimeaxisradial_p.h"
	22	#include "chartpresenter_p.h"
	23	#include "abstractchartlayout_p.h"
	24	#include "qdatetimeaxis.h"
	25
	26	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	27
	28	PolarChartDateTimeAxisRadial::PolarChartDateTimeAxisRadial(QDateTimeAxis axis, QGraphicsItem item)
	29	: PolarChartAxisRadial(axis, item)
	30	{
	31	QObject::connect(axis, SIGNAL(tickCountChanged(int)), this, SLOT(handleTickCountChanged(int)));
	32	QObject::connect(axis, SIGNAL(formatChanged(QString)), this, SLOT(handleFormatChanged(QString)));
	33	}
	34
	35	PolarChartDateTimeAxisRadial::~PolarChartDateTimeAxisRadial()
	36	{
	37	}
	38
	39	QVector<qreal> PolarChartDateTimeAxisRadial::calculateLayout() const
	40	{
	41	int tickCount = static_cast<QDateTimeAxis *>(axis())->tickCount();
	42	Q_ASSERT(tickCount >= 2);
	43
	44	QVector<qreal> points;
	45	points.resize(tickCount);
	46
	47	const qreal d = (axisGeometry().width() / 2) / qreal(tickCount - 1);
	48
	49	for (int i = 0; i < tickCount; ++i) {
	50	qreal radialCoordinate = qreal(i) * d;
	51	points[i] = radialCoordinate;
	52	}
	53
	54	return points;
	55	}
	56	void PolarChartDateTimeAxisRadial::createAxisLabels(const QVector<qreal> &layout)
	57	{
	58	setLabels(createDateTimeLabels(min(), max(), layout.size(), static_cast<QDateTimeAxis *>(axis())->format()));
	59	}
	60
	61	void PolarChartDateTimeAxisRadial::handleTickCountChanged(int tick)
	62	{
	63	Q_UNUSED(tick);
	64	QGraphicsLayoutItem::updateGeometry();
	65	if (presenter())
	66	presenter()->layout()->invalidate();
	67	}
	68
	69	void PolarChartDateTimeAxisRadial::handleFormatChanged(const QString &format)
	70	{
	71	Q_UNUSED(format);
	72	QGraphicsLayoutItem::updateGeometry();
	73	if (presenter())
	74	presenter()->layout()->invalidate();
	75	}
	76
	77	#include "moc_polarchartdatetimeaxisradial_p.cpp"
	78
	79	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/datetimeaxis/polarchartdatetimeaxisradial_p.h created 644 +56 0

@@ -0,0 +1,56
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef POLARCHARTDATETIMEAXISRADIAL_P_H
	31	#define POLARCHARTDATETIMEAXISRADIAL_P_H
	32
	33	#include "polarchartaxisradial_p.h"
	34
	35	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	36
	37	class QDateTimeAxis;
	38
	39	class PolarChartDateTimeAxisRadial : public PolarChartAxisRadial
	40	{
	41	Q_OBJECT
	42	public:
	43	PolarChartDateTimeAxisRadial(QDateTimeAxis axis, QGraphicsItem item);
	44	~PolarChartDateTimeAxisRadial();
	45
	46	virtual QVector<qreal> calculateLayout() const;
	47	virtual void createAxisLabels(const QVector<qreal> &layout);
	48
	49	private Q_SLOTS:
	50	void handleTickCountChanged(int tick);
	51	void handleFormatChanged(const QString &format);
	52	};
	53
	54	QTCOMMERCIALCHART_END_NAMESPACE
	55
	56	#endif // POLARCHARTDATETIMEAXISRADIAL_P_H

src/axis/linearrowitem_p.h created 644 +76 0

@@ -0,0 +1,76
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef LINEARROWITEM_P_H
	31	#define LINEARROWITEM_P_H
	32
	33	#include "chartaxiselement_p.h"
	34	#include "qabstractaxis_p.h"
	35	#include <QGraphicsLineItem>
	36
	37	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	38
	39	class LineArrowItem: public QGraphicsLineItem
	40	{
	41	public:
	42	explicit LineArrowItem(ChartAxisElement axis, QGraphicsItem parent = 0)
	43	: QGraphicsLineItem(parent),
	44	m_axis(axis),
	45	m_axisOrientation(axis->axis()->orientation())
	46	{
	47	}
	48
	49	protected:
	50	void mousePressEvent(QGraphicsSceneMouseEvent *event)
	51	{
	52	Q_UNUSED(event)
	53	m_axis->axisSelected();
	54	}
	55
	56	QRectF boundingRect() const
	57	{
	58	return shape().boundingRect();
	59	}
	60
	61	QPainterPath shape() const
	62	{
	63	QPainterPath path = QGraphicsLineItem::shape();
	64	QRectF rect = path.boundingRect();
	65	path.addRect(rect.adjusted(0, 0, m_axisOrientation != Qt::Horizontal ? 8 : 0, m_axisOrientation != Qt::Vertical ? 8 : 0));
	66	return path;
	67	}
	68
	69	private:
	70	ChartAxisElement *m_axis;
	71	Qt::Orientation m_axisOrientation;
	72	};
	73
	74	QTCOMMERCIALCHART_END_NAMESPACE
	75
	76	#endif /* LINEARROWITEM_P_H */

src/axis/logvalueaxis/polarchartlogvalueaxisangular.cpp created 644 +90 0

@@ -0,0 +1,90
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "polarchartlogvalueaxisangular_p.h"
	22	#include "abstractchartlayout_p.h"
	23	#include "chartpresenter_p.h"
	24	#include "qlogvalueaxis.h"
	25	#include <qmath.h>
	26	#include <QDebug>
	27
	28	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	29
	30	PolarChartLogValueAxisAngular::PolarChartLogValueAxisAngular(QLogValueAxis axis, QGraphicsItem item)
	31	: PolarChartAxisAngular(axis, item)
	32	{
	33	QObject::connect(axis, SIGNAL(baseChanged(qreal)), this, SLOT(handleBaseChanged(qreal)));
	34	QObject::connect(axis, SIGNAL(labelFormatChanged(QString)), this, SLOT(handleLabelFormatChanged(QString)));
	35	}
	36
	37	PolarChartLogValueAxisAngular::~PolarChartLogValueAxisAngular()
	38	{
	39	}
	40
	41	QVector<qreal> PolarChartLogValueAxisAngular::calculateLayout() const
	42	{
	43	QLogValueAxis logValueAxis = static_cast<QLogValueAxis >(axis());
	44	const qreal logMax = log10(logValueAxis->max()) / log10(logValueAxis->base());
	45	const qreal logMin = log10(logValueAxis->min()) / log10(logValueAxis->base());
	46	const qreal startEdge = logMin < logMax ? logMin : logMax;
	47	const qreal delta = 360.0 / qAbs(logMax - logMin);
	48	const qreal initialSpan = (ceil(startEdge) - startEdge) * delta;
	49	int tickCount = qAbs(ceil(logMax) - ceil(logMin));
	50
	51	QVector<qreal> points;
	52	points.resize(tickCount);
	53
	54	for (int i = 0; i < tickCount; ++i) {
	55	qreal angularCoordinate = initialSpan + (delta * qreal(i));
	56	points[i] = angularCoordinate;
	57	}
	58
	59	return points;
	60	}
	61
	62	void PolarChartLogValueAxisAngular::createAxisLabels(const QVector<qreal> &layout)
	63	{
	64	QLogValueAxis logValueAxis = static_cast<QLogValueAxis >(axis());
	65	setLabels(createLogValueLabels(logValueAxis->min(),
	66	logValueAxis->max(),
	67	logValueAxis->base(),
	68	layout.size(),
	69	logValueAxis->labelFormat()));
	70	}
	71
	72	void PolarChartLogValueAxisAngular::handleBaseChanged(qreal base)
	73	{
	74	Q_UNUSED(base);
	75	QGraphicsLayoutItem::updateGeometry();
	76	if (presenter())
	77	presenter()->layout()->invalidate();
	78	}
	79
	80	void PolarChartLogValueAxisAngular::handleLabelFormatChanged(const QString &format)
	81	{
	82	Q_UNUSED(format);
	83	QGraphicsLayoutItem::updateGeometry();
	84	if (presenter())
	85	presenter()->layout()->invalidate();
	86	}
	87
	88	#include "moc_polarchartlogvalueaxisangular_p.cpp"
	89
	90	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/logvalueaxis/polarchartlogvalueaxisangular_p.h created 644 +57 0

@@ -0,0 +1,57
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef POLARCHARTLOGVALUEAXISANGULAR_P_H
	31	#define POLARCHARTLOGVALUEAXISANGULAR_P_H
	32
	33	#include "polarchartaxisangular_p.h"
	34
	35	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	36
	37	class QLogValueAxis;
	38
	39	class PolarChartLogValueAxisAngular : public PolarChartAxisAngular
	40	{
	41	Q_OBJECT
	42	public:
	43	PolarChartLogValueAxisAngular(QLogValueAxis axis, QGraphicsItem item);
	44	~PolarChartLogValueAxisAngular();
	45
	46	protected:
	47	virtual QVector<qreal> calculateLayout() const;
	48	virtual void createAxisLabels(const QVector<qreal> &layout);
	49
	50	private Q_SLOTS:
	51	void handleBaseChanged(qreal base);
	52	void handleLabelFormatChanged(const QString &format);
	53	};
	54
	55	QTCOMMERCIALCHART_END_NAMESPACE
	56
	57	#endif // POLARCHARTLOGVALUEAXISANGULAR_P_H

src/axis/logvalueaxis/polarchartlogvalueaxisradial.cpp created 644 +95 0

@@ -0,0 +1,95
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "polarchartlogvalueaxisradial_p.h"
	22	#include "abstractchartlayout_p.h"
	23	#include "chartpresenter_p.h"
	24	#include "qlogvalueaxis.h"
	25	#include <qmath.h>
	26	#include <QDebug>
	27
	28	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	29
	30	PolarChartLogValueAxisRadial::PolarChartLogValueAxisRadial(QLogValueAxis axis, QGraphicsItem item)
	31	: PolarChartAxisRadial(axis, item)
	32	{
	33	QObject::connect(axis, SIGNAL(baseChanged(qreal)), this, SLOT(handleBaseChanged(qreal)));
	34	QObject::connect(axis, SIGNAL(labelFormatChanged(QString)), this, SLOT(handleLabelFormatChanged(QString)));
	35	}
	36
	37	PolarChartLogValueAxisRadial::~PolarChartLogValueAxisRadial()
	38	{
	39	}
	40
	41	QVector<qreal> PolarChartLogValueAxisRadial::calculateLayout() const
	42	{
	43	QLogValueAxis logValueAxis = static_cast<QLogValueAxis >(axis());
	44	const qreal logMax = log10(logValueAxis->max()) / log10(logValueAxis->base());
	45	const qreal logMin = log10(logValueAxis->min()) / log10(logValueAxis->base());
	46	const qreal innerEdge = logMin < logMax ? logMin : logMax;
	47	const qreal outerEdge = logMin > logMax ? logMin : logMax;
	48	const qreal delta = (axisGeometry().width() / 2.0) / qAbs(logMax - logMin);
	49	const qreal initialSpan = (ceil(innerEdge) - innerEdge) * delta;
	50	int tickCount = qAbs(ceil(logMax) - ceil(logMin));
	51
	52	// Extra tick if outer edge is exactly at the tick
	53	if (outerEdge == ceil(outerEdge))
	54	tickCount++;
	55
	56	QVector<qreal> points;
	57	points.resize(tickCount);
	58
	59	for (int i = 0; i < tickCount; ++i) {
	60	qreal radialCoordinate = initialSpan + (delta * qreal(i));
	61	points[i] = radialCoordinate;
	62	}
	63
	64	return points;
	65	}
	66
	67	void PolarChartLogValueAxisRadial::createAxisLabels(const QVector<qreal> &layout)
	68	{
	69	QLogValueAxis logValueAxis = static_cast<QLogValueAxis >(axis());
	70	setLabels(createLogValueLabels(logValueAxis->min(),
	71	logValueAxis->max(),
	72	logValueAxis->base(),
	73	layout.size(),
	74	logValueAxis->labelFormat()));
	75	}
	76
	77	void PolarChartLogValueAxisRadial::handleBaseChanged(qreal base)
	78	{
	79	Q_UNUSED(base);
	80	QGraphicsLayoutItem::updateGeometry();
	81	if (presenter())
	82	presenter()->layout()->invalidate();
	83	}
	84
	85	void PolarChartLogValueAxisRadial::handleLabelFormatChanged(const QString &format)
	86	{
	87	Q_UNUSED(format);
	88	QGraphicsLayoutItem::updateGeometry();
	89	if (presenter())
	90	presenter()->layout()->invalidate();
	91	}
	92
	93	#include "moc_polarchartlogvalueaxisradial_p.cpp"
	94
	95	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/logvalueaxis/polarchartlogvalueaxisradial_p.h created 644 +57 0

@@ -0,0 +1,57
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef POLARCHARTLOGVALUEAXISRADIAL_P_H
	31	#define POLARCHARTLOGVALUEAXISRADIAL_P_H
	32
	33	#include "polarchartaxisradial_p.h"
	34
	35	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	36
	37	class QLogValueAxis;
	38
	39	class PolarChartLogValueAxisRadial : public PolarChartAxisRadial
	40	{
	41	Q_OBJECT
	42	public:
	43	PolarChartLogValueAxisRadial(QLogValueAxis axis, QGraphicsItem item);
	44	~PolarChartLogValueAxisRadial();
	45
	46	protected:
	47	virtual QVector<qreal> calculateLayout() const;
	48	virtual void createAxisLabels(const QVector<qreal> &layout);
	49
	50	private Q_SLOTS:
	51	void handleBaseChanged(qreal base);
	52	void handleLabelFormatChanged(const QString &format);
	53	};
	54
	55	QTCOMMERCIALCHART_END_NAMESPACE
	56
	57	#endif // POLARCHARTLOGVALUEAXISRADIAL_P_H

src/axis/polarchartaxis.cpp created 644 +120 0

@@ -0,0 +1,120
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "polarchartaxis_p.h"
	22	#include "qabstractaxis_p.h"
	23	#include "chartpresenter_p.h"
	24
	25	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	26
	27	PolarChartAxis::PolarChartAxis(QAbstractAxis axis, QGraphicsItem item, bool intervalAxis)
	28	: ChartAxisElement(axis, item, intervalAxis)
	29	{
	30	}
	31
	32	PolarChartAxis::~PolarChartAxis()
	33	{
	34
	35	}
	36
	37	void PolarChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
	38	{
	39	Q_UNUSED(grid);
	40	setAxisGeometry(axis);
	41
	42	if (isEmpty())
	43	return;
	44
	45	QVector<qreal> layout = calculateLayout();
	46	updateLayout(layout);
	47	}
	48
	49	QRectF PolarChartAxis::gridGeometry() const
	50	{
	51	return QRectF();
	52	}
	53
	54	void PolarChartAxis::updateLayout(QVector<qreal> &layout)
	55	{
	56	int diff = ChartAxisElement::layout().size() - layout.size();
	57
	58	if (animation()) {
	59	switch (presenter()->state()) {
	60	case ChartPresenter::ShowState:
	61	animation()->setAnimationType(AxisAnimation::DefaultAnimation);
	62	break;
	63	}
	64	// Update to "old" geometry before starting animation to avoid incorrectly sized
	65	// axes lingering in wrong position compared to series plot before animation can kick in.
	66	// Note that the position mismatch still exists even with this update, but it will be
	67	// far less ugly.
	68	updateGeometry();
	69	}
	70
	71	if (diff > 0)
	72	deleteItems(diff);
	73	else if (diff < 0)
	74	createItems(-diff);
	75
	76	if (animation()) {
	77	animation()->setValues(ChartAxisElement::layout(), layout);
	78	presenter()->startAnimation(animation());
	79	} else {
	80	setLayout(layout);
	81	updateGeometry();
	82	}
	83	}
	84
	85	bool PolarChartAxis::isEmpty()
	86	{
	87	return !axisGeometry().isValid() \|\| qFuzzyIsNull(min() - max());
	88	}
	89
	90	void PolarChartAxis::deleteItems(int count)
	91	{
	92	QList<QGraphicsItem *> gridLines = gridItems();
	93	QList<QGraphicsItem *> labels = labelItems();
	94	QList<QGraphicsItem *> shades = shadeItems();
	95	QList<QGraphicsItem *> axis = arrowItems();
	96
	97	for (int i = 0; i < count; ++i) {
	98	if (gridItems().size() == 1 \|\| (((gridLines.size() + 1) % 2) && gridLines.size() > 0))
	99	delete(shades.takeLast());
	100	delete(gridLines.takeLast());
	101	delete(labels.takeLast());
	102	delete(axis.takeLast());
	103	}
	104	}
	105
	106	void PolarChartAxis::handleShadesBrushChanged(const QBrush &brush)
	107	{
	108	foreach (QGraphicsItem *item, shadeItems())
	109	static_cast<QGraphicsPathItem *>(item)->setBrush(brush);
	110	}
	111
	112	void PolarChartAxis::handleShadesPenChanged(const QPen &pen)
	113	{
	114	foreach (QGraphicsItem *item, shadeItems())
	115	static_cast<QGraphicsPathItem *>(item)->setPen(pen);
	116	}
	117
	118	#include "moc_polarchartaxis_p.cpp"
	119
	120	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/polarchartaxis_p.h created 644 +70 0

@@ -0,0 +1,70
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef POLARCHARTAXIS_P_H
	31	#define POLARCHARTAXIS_P_H
	32
	33	#include "chartaxiselement_p.h"
	34
	35	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	36
	37	class PolarChartAxis : public ChartAxisElement
	38	{
	39	Q_OBJECT
	40	Q_INTERFACES(QGraphicsLayoutItem)
	41	public:
	42	PolarChartAxis(QAbstractAxis axis, QGraphicsItem item, bool intervalAxis = false);
	43	~PolarChartAxis();
	44
	45	void setGeometry(const QRectF &axis, const QRectF &grid);
	46	virtual qreal preferredAxisRadius(const QSizeF &maxSize) = 0;
	47	int tickWidth() { return 3; }
	48
	49	public: // from ChartAxisElement
	50	QRectF gridGeometry() const;
	51	bool isEmpty();
	52
	53	protected:
	54	void updateLayout(QVector<qreal> &layout);
	55
	56	protected: // virtual functions
	57	virtual void createItems(int count) = 0;
	58	virtual void createAxisLabels(const QVector<qreal> &layout) = 0;
	59
	60	public Q_SLOTS:
	61	virtual void handleShadesBrushChanged(const QBrush &brush);
	62	virtual void handleShadesPenChanged(const QPen &pen);
	63
	64	private:
	65	void deleteItems(int count);
	66	};
	67
	68	QTCOMMERCIALCHART_END_NAMESPACE
	69
	70	#endif // POLARCHARTAXIS_P_H

src/axis/polarchartaxisangular.cpp created 644 +428 0

@@ -0,0 +1,428
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "polarchartaxisangular_p.h"
	22	#include "chartpresenter_p.h"
	23	#include "abstractchartlayout_p.h"
	24	#include "qabstractaxis.h"
	25	#include "qabstractaxis_p.h"
	26	#include <QFontMetrics>
	27	#include <QDebug>
	28
	29	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	30
	31	PolarChartAxisAngular::PolarChartAxisAngular(QAbstractAxis axis, QGraphicsItem item, bool intervalAxis)
	32	: PolarChartAxis(axis, item, intervalAxis)
	33	{
	34	}
	35
	36	PolarChartAxisAngular::~PolarChartAxisAngular()
	37	{
	38	}
	39
	40	void PolarChartAxisAngular::updateGeometry()
	41	{
	42	QGraphicsLayoutItem::updateGeometry();
	43
	44	const QVector<qreal> &layout = this->layout();
	45	if (layout.isEmpty())
	46	return;
	47
	48	createAxisLabels(layout);
	49	QStringList labelList = labels();
	50	QPointF center = axisGeometry().center();
	51	QList<QGraphicsItem *> arrowItemList = arrowItems();
	52	QList<QGraphicsItem *> gridItemList = gridItems();
	53	QList<QGraphicsItem *> labelItemList = labelItems();
	54	QList<QGraphicsItem *> shadeItemList = shadeItems();
	55	QGraphicsSimpleTextItem *title = titleItem();
	56
	57	QGraphicsEllipseItem axisLine = static_cast<QGraphicsEllipseItem >(arrowItemList.at(0));
	58	axisLine->setRect(axisGeometry());
	59
	60	qreal radius = axisGeometry().height() / 2.0;
	61
	62	QFontMetrics fn(axis()->labelsFont());
	63	QRectF previousLabelRect;
	64	QRectF firstLabelRect;
	65
	66	qreal labelHeight = 0;
	67
	68	bool firstShade = true;
	69	bool nextTickVisible = false;
	70	if (layout.size())
	71	nextTickVisible = !(layout.at(0) < 0.0 \|\| layout.at(0) > 360.0);
	72
	73	for (int i = 0; i < layout.size(); ++i) {
	74	qreal angularCoordinate = layout.at(i);
	75
	76	QGraphicsLineItem gridLineItem = static_cast<QGraphicsLineItem >(gridItemList.at(i));
	77	QGraphicsLineItem tickItem = static_cast<QGraphicsLineItem >(arrowItemList.at(i + 1));
	78	QGraphicsSimpleTextItem labelItem = static_cast<QGraphicsSimpleTextItem >(labelItemList.at(i));
	79	QGraphicsPathItem *shadeItem = 0;
	80	if (i == 0)
	81	shadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at(0));
	82	else if (i % 2)
	83	shadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at((i / 2) + 1));
	84
	85	// Ignore ticks outside valid range
	86	bool currentTickVisible = nextTickVisible;
	87	if ((i == layout.size() - 1)
	88	\|\| layout.at(i + 1) < 0.0
	89	\|\| layout.at(i + 1) > 360.0) {
	90	nextTickVisible = false;
	91	} else {
	92	nextTickVisible = true;
	93	}
	94
	95	qreal labelCoordinate = angularCoordinate;
	96	qreal labelVisible = currentTickVisible;
	97	if (intervalAxis()) {
	98	qreal farEdge;
	99	if (i == (layout.size() - 1))
	100	farEdge = 360.0;
	101	else
	102	farEdge = qMin(360.0, layout.at(i + 1));
	103
	104	// Adjust the labelCoordinate to show it if next tick is visible
	105	if (nextTickVisible)
	106	labelCoordinate = qMax(0.0, labelCoordinate);
	107
	108	labelCoordinate = (labelCoordinate + farEdge) / 2.0;
	109	// Don't display label once the category gets too small near the axis
	110	if (labelCoordinate < 5.0 \|\| labelCoordinate > 355.0)
	111	labelVisible = false;
	112	else
	113	labelVisible = true;
	114	}
	115
	116	// Need this also in label calculations, so determine it first
	117	QLineF tickLine(QLineF::fromPolar(radius - tickWidth(), 90.0 - angularCoordinate).p2(),
	118	QLineF::fromPolar(radius + tickWidth(), 90.0 - angularCoordinate).p2());
	119	tickLine.translate(center);
	120
	121	// Angular axis label
	122	if (axis()->labelsVisible() && labelVisible) {
	123	labelItem->setText(labelList.at(i));
	124	const QRectF &rect = labelItem->boundingRect();
	125	QPointF labelCenter = rect.center();
	126	labelItem->setTransformOriginPoint(labelCenter.x(), labelCenter.y());
	127	QRectF boundingRect = labelBoundingRect(fn, labelList.at(i));
	128	boundingRect.moveCenter(labelCenter);
	129	QPointF positionDiff(rect.topLeft() - boundingRect.topLeft());
	130
	131	QPointF labelPoint;
	132	if (intervalAxis()) {
	133	QLineF labelLine = QLineF::fromPolar(radius + tickWidth(), 90.0 - labelCoordinate);
	134	labelLine.translate(center);
	135	labelPoint = labelLine.p2();
	136	} else {
	137	labelPoint = tickLine.p2();
	138	}
	139
	140	QRectF labelRect = moveLabelToPosition(labelCoordinate, labelPoint, boundingRect);
	141	labelItem->setPos(labelRect.topLeft() + positionDiff);
	142
	143	// Store height for title calculations
	144	qreal labelClearance = axisGeometry().top() - labelRect.top();
	145	labelHeight = qMax(labelHeight, labelClearance);
	146
	147	// Label overlap detection
	148	if (i && (previousLabelRect.intersects(labelRect) \|\| firstLabelRect.intersects(labelRect))) {
	149	labelVisible = false;
	150	} else {
	151	// Store labelRect for future comparison. Some area is deducted to make things look
	152	// little nicer, as usually intersection happens at label corner with angular labels.
	153	labelRect.adjust(-2.0, -4.0, -2.0, -4.0);
	154	if (firstLabelRect.isEmpty())
	155	firstLabelRect = labelRect;
	156
	157	previousLabelRect = labelRect;
	158	labelVisible = true;
	159	}
	160	}
	161
	162	labelItem->setVisible(labelVisible);
	163	if (!currentTickVisible) {
	164	gridLineItem->setVisible(false);
	165	tickItem->setVisible(false);
	166	if (shadeItem)
	167	shadeItem->setVisible(false);
	168	continue;
	169	}
	170
	171	// Angular grid line
	172	QLineF gridLine = QLineF::fromPolar(radius, 90.0 - angularCoordinate);
	173	gridLine.translate(center);
	174	gridLineItem->setLine(gridLine);
	175	gridLineItem->setVisible(true);
	176
	177	// Tick
	178	tickItem->setLine(tickLine);
	179	tickItem->setVisible(true);
	180
	181	// Shades
	182	if (i % 2 \|\| (i == 0 && !nextTickVisible)) {
	183	QPainterPath path;
	184	path.moveTo(center);
	185	if (i == 0) {
	186	// If first tick is also the last, we need to custom fill the first partial arc
	187	// or it won't get filled.
	188	path.arcTo(axisGeometry(), 90.0 - layout.at(0), layout.at(0));
	189	path.closeSubpath();
	190	} else {
	191	qreal nextCoordinate;
	192	if (!nextTickVisible) // Last visible tick
	193	nextCoordinate = 360.0;
	194	else
	195	nextCoordinate = layout.at(i + 1);
	196	qreal arcSpan = angularCoordinate - nextCoordinate;
	197	path.arcTo(axisGeometry(), 90.0 - angularCoordinate, arcSpan);
	198	path.closeSubpath();
	199
	200	// Add additional arc for first shade item if there is a partial arc to be filled
	201	if (firstShade) {
	202	QGraphicsPathItem specialShadeItem = static_cast<QGraphicsPathItem >(shadeItemList.at(0));
	203	if (layout.at(i - 1) > 0.0) {
	204	QPainterPath specialPath;
	205	specialPath.moveTo(center);
	206	specialPath.arcTo(axisGeometry(), 90.0 - layout.at(i - 1), layout.at(i - 1));
	207	specialPath.closeSubpath();
	208	specialShadeItem->setPath(specialPath);
	209	specialShadeItem->setVisible(true);
	210	} else {
	211	specialShadeItem->setVisible(false);
	212	}
	213	}
	214	}
	215	shadeItem->setPath(path);
	216	shadeItem->setVisible(true);
	217	firstShade = false;
	218	}
	219	}
	220
	221	// Title, centered above the chart
	222	QString titleText = axis()->titleText();
	223	if (!titleText.isEmpty() && axis()->isTitleVisible()) {
	224	int size(0);
	225	size = axisGeometry().width();
	226
	227	QFontMetrics titleMetrics(axis()->titleFont());
	228	if (titleMetrics.boundingRect(titleText).width() > size) {
	229	QString string = titleText + "...";
	230	while (titleMetrics.boundingRect(string).width() > size && string.length() > 3)
	231	string.remove(string.length() - 4, 1);
	232	title->setText(string);
	233	} else {
	234	title->setText(titleText);
	235	}
	236
	237	QRectF titleBoundingRect;
	238	titleBoundingRect = title->boundingRect();
	239	QPointF titleCenter = center - titleBoundingRect.center();
	240	title->setPos(titleCenter.x(), axisGeometry().top() - qreal(titlePadding()) * 2.0 - titleBoundingRect.height() - labelHeight);
	241	}
	242	}
	243
	244	Qt::Orientation PolarChartAxisAngular::orientation() const
	245	{
	246	return Qt::Horizontal;
	247	}
	248
	249	void PolarChartAxisAngular::createItems(int count)
	250	{
	251	if (arrowItems().count() == 0) {
	252	// angular axis line
	253	// TODO: need class similar to LineArrowItem for click handling?
	254	QGraphicsEllipseItem *arrow = new QGraphicsEllipseItem(presenter()->rootItem());
	255	arrow->setPen(axis()->linePen());
	256	arrowGroup()->addToGroup(arrow);
	257	}
	258
	259	for (int i = 0; i < count; ++i) {
	260	QGraphicsLineItem *arrow = new QGraphicsLineItem(presenter()->rootItem());
	261	QGraphicsLineItem *grid = new QGraphicsLineItem(presenter()->rootItem());
	262	QGraphicsSimpleTextItem *label = new QGraphicsSimpleTextItem(presenter()->rootItem());
	263	QGraphicsSimpleTextItem *title = titleItem();
	264	arrow->setPen(axis()->linePen());
	265	grid->setPen(axis()->gridLinePen());
	266	label->setFont(axis()->labelsFont());
	267	label->setPen(axis()->labelsPen());
	268	label->setBrush(axis()->labelsBrush());
	269	label->setRotation(axis()->labelsAngle());
	270	title->setFont(axis()->titleFont());
	271	title->setPen(axis()->titlePen());
	272	title->setBrush(axis()->titleBrush());
	273	title->setText(axis()->titleText());
	274	arrowGroup()->addToGroup(arrow);
	275	gridGroup()->addToGroup(grid);
	276	labelGroup()->addToGroup(label);
	277	if (gridItems().size() == 1 \|\| (((gridItems().size() + 1) % 2) && gridItems().size() > 0)) {
	278	QGraphicsPathItem *shade = new QGraphicsPathItem(presenter()->rootItem());
	279	shade->setPen(axis()->shadesPen());
	280	shade->setBrush(axis()->shadesBrush());
	281	shadeGroup()->addToGroup(shade);
	282	}
	283	}
	284	}
	285
	286	void PolarChartAxisAngular::handleArrowPenChanged(const QPen &pen)
	287	{
	288	bool first = true;
	289	foreach (QGraphicsItem *item, arrowItems()) {
	290	if (first) {
	291	first = false;
	292	// First arrow item is the outer circle of axis
	293	static_cast<QGraphicsEllipseItem *>(item)->setPen(pen);
	294	} else {
	295	static_cast<QGraphicsLineItem *>(item)->setPen(pen);
	296	}
	297	}
	298	}
	299
	300	void PolarChartAxisAngular::handleGridPenChanged(const QPen &pen)
	301	{
	302	foreach (QGraphicsItem *item, gridItems())
	303	static_cast<QGraphicsLineItem *>(item)->setPen(pen);
	304	}
	305
	306	QSizeF PolarChartAxisAngular::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
	307	{
	308	Q_UNUSED(which);
	309	Q_UNUSED(constraint);
	310	return QSizeF(-1, -1);
	311	}
	312
	313	qreal PolarChartAxisAngular::preferredAxisRadius(const QSizeF &maxSize)
	314	{
	315	qreal radius = maxSize.height() / 2.0;
	316	if (maxSize.width() < maxSize.height())
	317	radius = maxSize.width() / 2.0;
	318
	319	int labelHeight = 0;
	320
	321	if (axis()->labelsVisible()) {
	322	QVector<qreal> layout = calculateLayout();
	323	if (layout.isEmpty())
	324	return radius;
	325
	326	createAxisLabels(layout);
	327	QStringList labelList = labels();
	328	QFont font = axis()->labelsFont();
	329
	330	QRectF maxRect;
	331	maxRect.setSize(maxSize);
	332	maxRect.moveCenter(QPointF(0.0, 0.0));
	333
	334	// This is a horrible way to find out the maximum radius for angular axis and its labels.
	335	// It just increments the radius down until everyhing fits the constraint size.
	336	// Proper way would be to actually calculate it but this seems to work reasonably fast as it is.
	337	QFontMetrics fm(font);
	338	bool nextTickVisible = false;
	339	for (int i = 0; i < layout.size(); ) {
	340	if ((i == layout.size() - 1)
	341	\|\| layout.at(i + 1) < 0.0
	342	\|\| layout.at(i + 1) > 360.0) {
	343	nextTickVisible = false;
	344	} else {
	345	nextTickVisible = true;
	346	}
	347
	348	qreal labelCoordinate = layout.at(i);
	349	qreal labelVisible;
	350
	351	if (intervalAxis()) {
	352	qreal farEdge;
	353	if (i == (layout.size() - 1))
	354	farEdge = 360.0;
	355	else
	356	farEdge = qMin(360.0, layout.at(i + 1));
	357
	358	// Adjust the labelCoordinate to show it if next tick is visible
	359	if (nextTickVisible)
	360	labelCoordinate = qMax(0.0, labelCoordinate);
	361
	362	labelCoordinate = (labelCoordinate + farEdge) / 2.0;
	363	}
	364
	365	if (labelCoordinate < 0.0 \|\| labelCoordinate > 360.0)
	366	labelVisible = false;
	367	else
	368	labelVisible = true;
	369
	370	if (!labelVisible) {
	371	i++;
	372	continue;
	373	}
	374
	375	QRectF boundingRect = labelBoundingRect(fm, labelList.at(i));
	376	labelHeight = boundingRect.height();
	377	QPointF labelPoint = QLineF::fromPolar(radius + tickWidth(), 90.0 - labelCoordinate).p2();
	378
	379	boundingRect = moveLabelToPosition(labelCoordinate, labelPoint, boundingRect);
	380	if (boundingRect.isEmpty() \|\| maxRect.intersected(boundingRect) == boundingRect) {
	381	i++;
	382	} else {
	383	radius -= 1.0;
	384	if (radius < 1.0) // safeguard
	385	return 1.0;
	386	}
	387	}
	388	}
	389
	390	if (!axis()->titleText().isEmpty() && axis()->isTitleVisible()) {
	391	QFontMetrics titleMetrics(axis()->titleFont());
	392	int titleHeight = titleMetrics.boundingRect(axis()->titleText()).height();
	393	radius -= titlePadding() + (titleHeight / 2);
	394	if (radius < 1.0) // safeguard
	395	return 1.0;
	396	}
	397
	398	return radius;
	399	}
	400
	401	QRectF PolarChartAxisAngular::moveLabelToPosition(qreal angularCoordinate, QPointF labelPoint, QRectF labelRect) const
	402	{
	403	// TODO use fuzzy compare for "==" cases?
	404	// TODO Adjust the rect position near 0, 90, 180, and 270 angles for smoother animation?
	405	if (angularCoordinate == 0.0)
	406	labelRect.moveCenter(labelPoint + QPointF(0, -labelRect.height() / 2.0));
	407	else if (angularCoordinate < 90.0)
	408	labelRect.moveBottomLeft(labelPoint);
	409	else if (angularCoordinate == 90.0)
	410	labelRect.moveCenter(labelPoint + QPointF(labelRect.width() / 2.0 + 2.0, 0)); // +2 so that it does not hit the radial axis
	411	else if (angularCoordinate < 180.0)
	412	labelRect.moveTopLeft(labelPoint);
	413	else if (angularCoordinate == 180.0)
	414	labelRect.moveCenter(labelPoint + QPointF(0, labelRect.height() / 2.0));
	415	else if (angularCoordinate < 270.0)
	416	labelRect.moveTopRight(labelPoint);
	417	else if (angularCoordinate == 270.0)
	418	labelRect.moveCenter(labelPoint + QPointF(-labelRect.width() / 2.0 - 2.0, 0)); // -2 so that it does not hit the radial axis
	419	else if (angularCoordinate < 360.0)
	420	labelRect.moveBottomRight(labelPoint);
	421	else
	422	labelRect.moveCenter(labelPoint + QPointF(0, -labelRect.height() / 2.0));
	423	return labelRect;
	424	}
	425
	426	#include "moc_polarchartaxisangular_p.cpp"
	427
	428	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/polarchartaxisangular_p.h created 644 +63 0

@@ -0,0 +1,63
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef POLARCHARTAXISANGULAR_P_H
	31	#define POLARCHARTAXISANGULAR_P_H
	32
	33	#include "polarchartaxis_p.h"
	34	#include "qvalueaxis.h"
	35
	36	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	37
	38	class PolarChartAxisAngular : public PolarChartAxis
	39	{
	40	Q_OBJECT
	41	public:
	42	PolarChartAxisAngular(QAbstractAxis axis, QGraphicsItem item, bool intervalAxis = false);
	43	~PolarChartAxisAngular();
	44
	45	Qt::Orientation orientation() const;
	46	QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
	47
	48	virtual void updateGeometry();
	49	virtual void createItems(int count);
	50
	51	qreal preferredAxisRadius(const QSizeF &maxSize);
	52
	53	public Q_SLOTS:
	54	virtual void handleArrowPenChanged(const QPen &pen);
	55	virtual void handleGridPenChanged(const QPen &pen);
	56
	57	private:
	58	QRectF moveLabelToPosition(qreal angularCoordinate, QPointF labelPoint, QRectF labelRect) const;
	59	};
	60
	61	QTCOMMERCIALCHART_END_NAMESPACE
	62
	63	#endif // POLARCHARTAXISANGULAR_P_H

src/axis/polarchartaxisradial.cpp created 644 +301 0

@@ -0,0 +1,301
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "polarchartaxisradial_p.h"
	22	#include "chartpresenter_p.h"
	23	#include "abstractchartlayout_p.h"
	24	#include "qabstractaxis_p.h"
	25	#include "linearrowitem_p.h"
	26	#include <QFontMetrics>
	27
	28	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	29
	30	PolarChartAxisRadial::PolarChartAxisRadial(QAbstractAxis axis, QGraphicsItem item, bool intervalAxis)
	31	: PolarChartAxis(axis, item, intervalAxis)
	32	{
	33	}
	34
	35	PolarChartAxisRadial::~PolarChartAxisRadial()
	36	{
	37	}
	38
	39	void PolarChartAxisRadial::updateGeometry()
	40	{
	41	const QVector<qreal> &layout = this->layout();
	42	if (layout.isEmpty())
	43	return;
	44
	45	createAxisLabels(layout);
	46	QStringList labelList = labels();
	47	QPointF center = axisGeometry().center();
	48	QList<QGraphicsItem *> arrowItemList = arrowItems();
	49	QList<QGraphicsItem *> gridItemList = gridItems();
	50	QList<QGraphicsItem *> labelItemList = labelItems();
	51	QList<QGraphicsItem *> shadeItemList = shadeItems();
	52	QGraphicsSimpleTextItem* title = titleItem();
	53	qreal radius = axisGeometry().height() / 2.0;
	54
	55	QLineF line(center, center + QPointF(0, -radius));
	56	QGraphicsLineItem axisLine = static_cast<QGraphicsLineItem >(arrowItemList.at(0));
	57	axisLine->setLine(line);
	58
	59	QFontMetrics fn(axis()->labelsFont());
	60	QRectF previousLabelRect;
	61	bool firstShade = true;
	62	bool nextTickVisible = false;
	63	if (layout.size())
	64	nextTickVisible = !(layout.at(0) < 0.0 \|\| layout.at(0) > radius);
	65
	66	for (int i = 0; i < layout.size(); ++i) {
	67	qreal radialCoordinate = layout.at(i);
	68
	69	QGraphicsEllipseItem gridItem = static_cast<QGraphicsEllipseItem >(gridItemList.at(i));
	70	QGraphicsLineItem tickItem = static_cast<QGraphicsLineItem >(arrowItemList.at(i + 1));
	71	QGraphicsSimpleTextItem labelItem = static_cast<QGraphicsSimpleTextItem >(labelItemList.at(i));
	72	QGraphicsPathItem *shadeItem = 0;
	73	if (i == 0)
	74	shadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at(0));
	75	else if (i % 2)
	76	shadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at((i / 2) + 1));
	77
	78	// Ignore ticks outside valid range
	79	bool currentTickVisible = nextTickVisible;
	80	if ((i == layout.size() - 1)
	81	\|\| layout.at(i + 1) < 0.0
	82	\|\| layout.at(i + 1) > radius) {
	83	nextTickVisible = false;
	84	} else {
	85	nextTickVisible = true;
	86	}
	87
	88	qreal labelCoordinate = radialCoordinate;
	89	qreal labelVisible = currentTickVisible;
	90	qreal labelPad = labelPadding() / 2.0;
	91	if (intervalAxis()) {
	92	qreal farEdge;
	93	if (i == (layout.size() - 1))
	94	farEdge = radius;
	95	else
	96	farEdge = qMin(radius, layout.at(i + 1));
	97
	98	// Adjust the labelCoordinate to show it if next tick is visible
	99	if (nextTickVisible)
	100	labelCoordinate = qMax(0.0, labelCoordinate);
	101
	102	labelCoordinate = (labelCoordinate + farEdge) / 2.0;
	103	if (labelCoordinate > 0.0 && labelCoordinate < radius)
	104	labelVisible = true;
	105	else
	106	labelVisible = false;
	107	}
	108
	109	// Radial axis label
	110	if (axis()->labelsVisible() && labelVisible) {
	111	labelItem->setText(labelList.at(i));
	112	QRectF labelRect = labelItem->boundingRect();
	113	QPointF labelCenter = labelRect.center();
	114	labelItem->setTransformOriginPoint(labelCenter.x(), labelCenter.y());
	115	QRectF boundingRect = labelBoundingRect(fn, labelList.at(i));
	116	boundingRect.moveCenter(labelCenter);
	117	QPointF positionDiff(labelRect.topLeft() - boundingRect.topLeft());
	118	QPointF labelPoint = center;
	119	if (intervalAxis())
	120	labelPoint += QPointF(labelPad, -labelCoordinate - (boundingRect.height() / 2.0));
	121	else
	122	labelPoint += QPointF(labelPad, labelPad - labelCoordinate);
	123	labelRect.moveTopLeft(labelPoint);
	124	labelItem->setPos(labelRect.topLeft() + positionDiff);
	125
	126	// Label overlap detection
	127	labelRect.setSize(boundingRect.size());
	128	if ((i && previousLabelRect.intersects(labelRect))
	129	\|\| !axisGeometry().contains(labelRect)) {
	130	labelVisible = false;
	131	} else {
	132	previousLabelRect = labelRect;
	133	labelVisible = true;
	134	}
	135	}
	136
	137	labelItem->setVisible(labelVisible);
	138	if (!currentTickVisible) {
	139	gridItem->setVisible(false);
	140	tickItem->setVisible(false);
	141	if (shadeItem)
	142	shadeItem->setVisible(false);
	143	continue;
	144	}
	145
	146	// Radial grid line
	147	QRectF gridRect;
	148	gridRect.setWidth(radialCoordinate * 2.0);
	149	gridRect.setHeight(radialCoordinate * 2.0);
	150	gridRect.moveCenter(center);
	151
	152	gridItem->setRect(gridRect);
	153	gridItem->setVisible(true);
	154
	155	// Tick
	156	QLineF tickLine(-tickWidth(), 0.0, tickWidth(), 0.0);
	157	tickLine.translate(center.rx(), gridRect.top());
	158	tickItem->setLine(tickLine);
	159	tickItem->setVisible(true);
	160
	161	// Shades
	162	if (i % 2 \|\| (i == 0 && !nextTickVisible)) {
	163	QPainterPath path;
	164	if (i == 0) {
	165	// If first tick is also the last, we need to custom fill the inner circle
	166	// or it won't get filled.
	167	QRectF innerCircle(0.0, 0.0, layout.at(0) * 2.0, layout.at(0) * 2.0);
	168	innerCircle.moveCenter(center);
	169	path.addEllipse(innerCircle);
	170	} else {
	171	QRectF otherGridRect;
	172	if (!nextTickVisible) { // Last visible tick
	173	otherGridRect = axisGeometry();
	174	} else {
	175	qreal otherGridRectDimension = layout.at(i + 1) * 2.0;
	176	otherGridRect.setWidth(otherGridRectDimension);
	177	otherGridRect.setHeight(otherGridRectDimension);
	178	otherGridRect.moveCenter(center);
	179	}
	180	path.addEllipse(gridRect);
	181	path.addEllipse(otherGridRect);
	182
	183	// Add additional shading in first visible shade item if there is a partial tick
	184	// to be filled at the center (log & category axes)
	185	if (firstShade) {
	186	QGraphicsPathItem specialShadeItem = static_cast<QGraphicsPathItem >(shadeItemList.at(0));
	187	if (layout.at(i - 1) > 0.0) {
	188	QRectF innerCircle(0.0, 0.0, layout.at(i - 1) * 2.0, layout.at(i - 1) * 2.0);
	189	innerCircle.moveCenter(center);
	190	QPainterPath specialPath;
	191	specialPath.addEllipse(innerCircle);
	192	specialShadeItem->setPath(specialPath);
	193	specialShadeItem->setVisible(true);
	194	} else {
	195	specialShadeItem->setVisible(false);
	196	}
	197	}
	198	}
	199	shadeItem->setPath(path);
	200	shadeItem->setVisible(true);
	201	firstShade = false;
	202	}
	203	}
	204
	205	// Title, along the 0 axis
	206	QString titleText = axis()->titleText();
	207	if (!titleText.isEmpty() && axis()->isTitleVisible()) {
	208	QFontMetrics titleMetrics(axis()->titleFont());
	209	if (titleMetrics.boundingRect(titleText).width() > radius) {
	210	QString string = titleText + "...";
	211	while (titleMetrics.boundingRect(string).width() > radius && string.length() > 3)
	212	string.remove(string.length() - 4, 1);
	213	title->setText(string);
	214	} else {
	215	title->setText(titleText);
	216	}
	217
	218	QRectF titleBoundingRect;
	219	titleBoundingRect = title->boundingRect();
	220	QPointF titleCenter = titleBoundingRect.center();
	221	QPointF arrowCenter = axisLine->boundingRect().center();
	222	QPointF titleCenterDiff = arrowCenter - titleCenter;
	223	title->setPos(titleCenterDiff.x() - qreal(titlePadding()) - (titleBoundingRect.height() / 2.0), titleCenterDiff.y());
	224	title->setTransformOriginPoint(titleCenter);
	225	title->setRotation(270.0);
	226	}
	227
	228	QGraphicsLayoutItem::updateGeometry();
	229	}
	230
	231	Qt::Orientation PolarChartAxisRadial::orientation() const
	232	{
	233	return Qt::Vertical;
	234	}
	235
	236	void PolarChartAxisRadial::createItems(int count)
	237	{
	238	if (arrowItems().count() == 0) {
	239	// radial axis center line
	240	QGraphicsLineItem *arrow = new LineArrowItem(this, presenter()->rootItem());
	241	arrow->setPen(axis()->linePen());
	242	arrowGroup()->addToGroup(arrow);
	243	}
	244
	245	for (int i = 0; i < count; ++i) {
	246	QGraphicsLineItem *arrow = new QGraphicsLineItem(presenter()->rootItem());
	247	QGraphicsEllipseItem *grid = new QGraphicsEllipseItem(presenter()->rootItem());
	248	QGraphicsSimpleTextItem *label = new QGraphicsSimpleTextItem(presenter()->rootItem());
	249	QGraphicsSimpleTextItem *title = titleItem();
	250	arrow->setPen(axis()->linePen());
	251	grid->setPen(axis()->gridLinePen());
	252	label->setFont(axis()->labelsFont());
	253	label->setPen(axis()->labelsPen());
	254	label->setBrush(axis()->labelsBrush());
	255	label->setRotation(axis()->labelsAngle());
	256	title->setFont(axis()->titleFont());
	257	title->setPen(axis()->titlePen());
	258	title->setBrush(axis()->titleBrush());
	259	title->setText(axis()->titleText());
	260	arrowGroup()->addToGroup(arrow);
	261	gridGroup()->addToGroup(grid);
	262	labelGroup()->addToGroup(label);
	263	if (gridItems().size() == 1 \|\| (((gridItems().size() + 1) % 2) && gridItems().size() > 0)) {
	264	QGraphicsPathItem *shade = new QGraphicsPathItem(presenter()->rootItem());
	265	shade->setPen(axis()->shadesPen());
	266	shade->setBrush(axis()->shadesBrush());
	267	shadeGroup()->addToGroup(shade);
	268	}
	269	}
	270	}
	271
	272	void PolarChartAxisRadial::handleArrowPenChanged(const QPen &pen)
	273	{
	274	foreach (QGraphicsItem *item, arrowItems())
	275	static_cast<QGraphicsLineItem *>(item)->setPen(pen);
	276	}
	277
	278	void PolarChartAxisRadial::handleGridPenChanged(const QPen &pen)
	279	{
	280	foreach (QGraphicsItem *item, gridItems())
	281	static_cast<QGraphicsEllipseItem *>(item)->setPen(pen);
	282	}
	283
	284	QSizeF PolarChartAxisRadial::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
	285	{
	286	Q_UNUSED(which);
	287	Q_UNUSED(constraint);
	288	return QSizeF(-1.0, -1.0);
	289	}
	290
	291	qreal PolarChartAxisRadial::preferredAxisRadius(const QSizeF &maxSize)
	292	{
	293	qreal radius = maxSize.height() / 2.0;
	294	if (maxSize.width() < maxSize.height())
	295	radius = maxSize.width() / 2.0;
	296	return radius;
	297	}
	298
	299	#include "moc_polarchartaxisradial_p.cpp"
	300
	301	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/polarchartaxisradial_p.h created 644 +60 0

@@ -0,0 +1,60
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef POLARCHARTAXISRADIAL_P_H
	31	#define POLARCHARTAXISRADIAL_P_H
	32
	33	#include "polarchartaxis_p.h"
	34	#include "qvalueaxis.h"
	35
	36	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	37
	38	class PolarChartAxisRadial : public PolarChartAxis
	39	{
	40	Q_OBJECT
	41	public:
	42	PolarChartAxisRadial(QAbstractAxis axis, QGraphicsItem item, bool intervalAxis = false);
	43	~PolarChartAxisRadial();
	44
	45	Qt::Orientation orientation() const;
	46	QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
	47
	48	virtual void updateGeometry();
	49	virtual void createItems(int count);
	50
	51	qreal preferredAxisRadius(const QSizeF &maxSize);
	52
	53	public Q_SLOTS:
	54	virtual void handleArrowPenChanged(const QPen &pen);
	55	virtual void handleGridPenChanged(const QPen &pen);
	56	};
	57
	58	QTCOMMERCIALCHART_END_NAMESPACE
	59
	60	#endif // POLARCHARTAXISRADIAL_P_H

src/axis/valueaxis/polarchartvalueaxisangular.cpp created 644 +80 0

@@ -0,0 +1,80
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "polarchartvalueaxisangular_p.h"
	22	#include "chartpresenter_p.h"
	23	#include "abstractchartlayout_p.h"
	24
	25	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	26
	27	PolarChartValueAxisAngular::PolarChartValueAxisAngular(QValueAxis axis, QGraphicsItem item)
	28	: PolarChartAxisAngular(axis, item)
	29	{
	30	QObject::connect(axis, SIGNAL(tickCountChanged(int)), this, SLOT(handleTickCountChanged(int)));
	31	QObject::connect(axis, SIGNAL(labelFormatChanged(QString)), this, SLOT(handleLabelFormatChanged(QString)));
	32	}
	33
	34	PolarChartValueAxisAngular::~PolarChartValueAxisAngular()
	35	{
	36	}
	37
	38	QVector<qreal> PolarChartValueAxisAngular::calculateLayout() const
	39	{
	40	int tickCount = static_cast<QValueAxis *>(axis())->tickCount();
	41	Q_ASSERT(tickCount >= 2);
	42
	43	QVector<qreal> points;
	44	points.resize(tickCount);
	45
	46	const qreal d = 360.0 / qreal(tickCount - 1);
	47
	48	for (int i = 0; i < tickCount; ++i) {
	49	qreal angularCoordinate = qreal(i) * d;
	50	points[i] = angularCoordinate;
	51	}
	52
	53	return points;
	54	}
	55
	56	void PolarChartValueAxisAngular::createAxisLabels(const QVector<qreal> &layout)
	57	{
	58	QStringList labelList = createValueLabels(min(), max(), layout.size(), static_cast<QValueAxis *>(axis())->labelFormat());
	59	setLabels(labelList);
	60	}
	61
	62	void PolarChartValueAxisAngular::handleTickCountChanged(int tick)
	63	{
	64	Q_UNUSED(tick);
	65	QGraphicsLayoutItem::updateGeometry();
	66	if (presenter())
	67	presenter()->layout()->invalidate();
	68	}
	69
	70	void PolarChartValueAxisAngular::handleLabelFormatChanged(const QString &format)
	71	{
	72	Q_UNUSED(format);
	73	QGraphicsLayoutItem::updateGeometry();
	74	if (presenter())
	75	presenter()->layout()->invalidate();
	76	}
	77
	78	#include "moc_polarchartvalueaxisangular_p.cpp"
	79
	80	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/polarchartvalueaxisangular_p.h created 644 +56 0

@@ -0,0 +1,56
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef POLARCHARTVALUEAXISANGULAR_P_H
	31	#define POLARCHARTVALUEAXISANGULAR_P_H
	32
	33	#include "polarchartaxisangular_p.h"
	34
	35	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	36
	37	class QValueAxis;
	38
	39	class PolarChartValueAxisAngular : public PolarChartAxisAngular
	40	{
	41	Q_OBJECT
	42	public:
	43	PolarChartValueAxisAngular(QValueAxis axis, QGraphicsItem item);
	44	~PolarChartValueAxisAngular();
	45
	46	virtual QVector<qreal> calculateLayout() const;
	47	virtual void createAxisLabels(const QVector<qreal> &layout);
	48
	49	private Q_SLOTS:
	50	void handleTickCountChanged(int tick);
	51	void handleLabelFormatChanged(const QString &format);
	52	};
	53
	54	QTCOMMERCIALCHART_END_NAMESPACE
	55
	56	#endif // POLARCHARTVALUEAXISANGULAR_P_H

src/axis/valueaxis/polarchartvalueaxisradial.cpp created 644 +79 0

@@ -0,0 +1,79
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "polarchartvalueaxisradial_p.h"
	22	#include "chartpresenter_p.h"
	23	#include "abstractchartlayout_p.h"
	24
	25	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	26
	27	PolarChartValueAxisRadial::PolarChartValueAxisRadial(QValueAxis axis, QGraphicsItem item)
	28	: PolarChartAxisRadial(axis, item)
	29	{
	30	QObject::connect(axis, SIGNAL(tickCountChanged(int)), this, SLOT(handleTickCountChanged(int)));
	31	QObject::connect(axis, SIGNAL(labelFormatChanged(QString)), this, SLOT(handleLabelFormatChanged(QString)));
	32	}
	33
	34	PolarChartValueAxisRadial::~PolarChartValueAxisRadial()
	35	{
	36	}
	37
	38	QVector<qreal> PolarChartValueAxisRadial::calculateLayout() const
	39	{
	40	int tickCount = static_cast<QValueAxis *>(axis())->tickCount();
	41	Q_ASSERT(tickCount >= 2);
	42
	43	QVector<qreal> points;
	44	points.resize(tickCount);
	45
	46	const qreal d = (axisGeometry().width() / 2) / qreal(tickCount - 1);
	47
	48	for (int i = 0; i < tickCount; ++i) {
	49	qreal radialCoordinate = qreal(i) * d;
	50	points[i] = radialCoordinate;
	51	}
	52
	53	return points;
	54	}
	55
	56	void PolarChartValueAxisRadial::createAxisLabels(const QVector<qreal> &layout)
	57	{
	58	setLabels(createValueLabels(min(), max(), layout.size(), static_cast<QValueAxis *>(axis())->labelFormat()));
	59	}
	60
	61	void PolarChartValueAxisRadial::handleTickCountChanged(int tick)
	62	{
	63	Q_UNUSED(tick);
	64	QGraphicsLayoutItem::updateGeometry();
	65	if (presenter())
	66	presenter()->layout()->invalidate();
	67	}
	68
	69	void PolarChartValueAxisRadial::handleLabelFormatChanged(const QString &format)
	70	{
	71	Q_UNUSED(format);
	72	QGraphicsLayoutItem::updateGeometry();
	73	if (presenter())
	74	presenter()->layout()->invalidate();
	75	}
	76
	77	#include "moc_polarchartvalueaxisradial_p.cpp"
	78
	79	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/polarchartvalueaxisradial_p.h created 644 +56 0

@@ -0,0 +1,56
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef POLARCHARTVALUEAXISRADIAL_P_H
	31	#define POLARCHARTVALUEAXISRADIAL_P_H
	32
	33	#include "polarchartaxisradial_p.h"
	34
	35	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	36
	37	class QValueAxis;
	38
	39	class PolarChartValueAxisRadial : public PolarChartAxisRadial
	40	{
	41	Q_OBJECT
	42	public:
	43	PolarChartValueAxisRadial(QValueAxis axis, QGraphicsItem item);
	44	~PolarChartValueAxisRadial();
	45
	46	virtual QVector<qreal> calculateLayout() const;
	47	virtual void createAxisLabels(const QVector<qreal> &layout);
	48
	49	private Q_SLOTS:
	50	void handleTickCountChanged(int tick);
	51	void handleLabelFormatChanged(const QString &format);
	52	};
	53
	54	QTCOMMERCIALCHART_END_NAMESPACE
	55
	56	#endif // POLARCHARTVALUEAXISRADIAL_P_H

src/domain/logxlogypolardomain.cpp created 644 +267 0

@@ -0,0 +1,267
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "logxlogypolardomain_p.h"
	22	#include "qabstractaxis_p.h"
	23	#include "qlogvalueaxis.h"
	24	#include <qmath.h>
	25
	26	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	27
	28	LogXLogYPolarDomain::LogXLogYPolarDomain(QObject *parent)
	29	: PolarDomain(parent),
	30	m_logLeftX(0),
	31	m_logRightX(1),
	32	m_logBaseX(10),
	33	m_logInnerY(0),
	34	m_logOuterY(1),
	35	m_logBaseY(10)
	36	{
	37	}
	38
	39	LogXLogYPolarDomain::~LogXLogYPolarDomain()
	40	{
	41	}
	42
	43	void LogXLogYPolarDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
	44	{
	45	bool axisXChanged = false;
	46	bool axisYChanged = false;
	47
	48	adjustLogDomainRanges(minX, maxX);
	49	adjustLogDomainRanges(minY, maxY);
	50
	51	if (!qFuzzyCompare(m_minX, minX) \|\| !qFuzzyCompare(m_maxX, maxX)) {
	52	m_minX = minX;
	53	m_maxX = maxX;
	54	axisXChanged = true;
	55	qreal logMinX = log10(m_minX) / log10(m_logBaseX);
	56	qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
	57	m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
	58	m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
	59	if (!m_signalsBlocked)
	60	emit rangeHorizontalChanged(m_minX, m_maxX);
	61	}
	62
	63	if (!qFuzzyIsNull(m_minY - minY) \|\| !qFuzzyIsNull(m_maxY - maxY)) {
	64	m_minY = minY;
	65	m_maxY = maxY;
	66	axisYChanged = true;
	67	qreal logMinY = log10(m_minY) / log10(m_logBaseY);
	68	qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
	69	m_logInnerY = logMinY < logMaxY ? logMinY : logMaxY;
	70	m_logOuterY = logMinY > logMaxY ? logMinY : logMaxY;
	71	if (!m_signalsBlocked)
	72	emit rangeVerticalChanged(m_minY, m_maxY);
	73	}
	74
	75	if (axisXChanged \|\| axisYChanged)
	76	emit updated();
	77	}
	78
	79	void LogXLogYPolarDomain::zoomIn(const QRectF &rect)
	80	{
	81	qreal logLeftX = rect.left() * (m_logRightX - m_logLeftX) / m_size.width() + m_logLeftX;
	82	qreal logRightX = rect.right() * (m_logRightX - m_logLeftX) / m_size.width() + m_logLeftX;
	83	qreal leftX = qPow(m_logBaseX, logLeftX);
	84	qreal rightX = qPow(m_logBaseX, logRightX);
	85	qreal minX = leftX < rightX ? leftX : rightX;
	86	qreal maxX = leftX > rightX ? leftX : rightX;
	87
	88	qreal logLeftY = m_logOuterY - rect.bottom() * (m_logOuterY - m_logInnerY) / m_size.height();
	89	qreal logRightY = m_logOuterY - rect.top() * (m_logOuterY - m_logInnerY) / m_size.height();
	90	qreal leftY = qPow(m_logBaseY, logLeftY);
	91	qreal rightY = qPow(m_logBaseY, logRightY);
	92	qreal minY = leftY < rightY ? leftY : rightY;
	93	qreal maxY = leftY > rightY ? leftY : rightY;
	94
	95	setRange(minX, maxX, minY, maxY);
	96	}
	97
	98	void LogXLogYPolarDomain::zoomOut(const QRectF &rect)
	99	{
	100	const qreal factorX = m_size.width() / rect.width();
	101
	102	qreal logLeftX = m_logLeftX + (m_logRightX - m_logLeftX) / 2.0 * (1.0 - factorX);
	103	qreal logRIghtX = m_logLeftX + (m_logRightX - m_logLeftX) / 2.0 * (1.0 + factorX);
	104	qreal leftX = qPow(m_logBaseX, logLeftX);
	105	qreal rightX = qPow(m_logBaseX, logRIghtX);
	106	qreal minX = leftX < rightX ? leftX : rightX;
	107	qreal maxX = leftX > rightX ? leftX : rightX;
	108
	109	const qreal factorY = m_size.height() / rect.height();
	110	qreal newLogMinY = m_logInnerY + (m_logOuterY - m_logInnerY) / 2.0 * (1.0 - factorY);
	111	qreal newLogMaxY = m_logInnerY + (m_logOuterY - m_logInnerY) / 2.0 * (1.0 + factorY);
	112	qreal leftY = qPow(m_logBaseY, newLogMinY);
	113	qreal rightY = qPow(m_logBaseY, newLogMaxY);
	114	qreal minY = leftY < rightY ? leftY : rightY;
	115	qreal maxY = leftY > rightY ? leftY : rightY;
	116
	117	setRange(minX, maxX, minY, maxY);
	118	}
	119
	120	void LogXLogYPolarDomain::move(qreal dx, qreal dy)
	121	{
	122	qreal stepX = dx * (m_logRightX - m_logLeftX) / m_size.width();
	123	qreal leftX = qPow(m_logBaseX, m_logLeftX + stepX);
	124	qreal rightX = qPow(m_logBaseX, m_logRightX + stepX);
	125	qreal minX = leftX < rightX ? leftX : rightX;
	126	qreal maxX = leftX > rightX ? leftX : rightX;
	127
	128	qreal stepY = dy * (m_logOuterY - m_logInnerY) / m_radius;
	129	qreal leftY = qPow(m_logBaseY, m_logInnerY + stepY);
	130	qreal rightY = qPow(m_logBaseY, m_logOuterY + stepY);
	131	qreal minY = leftY < rightY ? leftY : rightY;
	132	qreal maxY = leftY > rightY ? leftY : rightY;
	133
	134	setRange(minX, maxX, minY, maxY);
	135	}
	136
	137	qreal LogXLogYPolarDomain::toAngularCoordinate(qreal value, bool &ok) const
	138	{
	139	qreal retVal;
	140	if (value <= 0) {
	141	ok = false;
	142	retVal = 0.0;
	143	} else {
	144	ok = true;
	145	const qreal tickSpan = 360.0 / qAbs(m_logRightX - m_logLeftX);
	146	const qreal logValue = log10(value) / log10(m_logBaseX);
	147	const qreal valueDelta = logValue - m_logLeftX;
	148
	149	retVal = valueDelta * tickSpan;
	150	}
	151	return retVal;
	152	}
	153
	154	qreal LogXLogYPolarDomain::toRadialCoordinate(qreal value, bool &ok) const
	155	{
	156	qreal retVal;
	157	if (value <= 0) {
	158	ok = false;
	159	retVal = 0.0;
	160	} else {
	161	ok = true;
	162	const qreal tickSpan = m_radius / qAbs(m_logOuterY - m_logInnerY);
	163	const qreal logValue = log10(value) / log10(m_logBaseY);
	164	const qreal valueDelta = logValue - m_logInnerY;
	165
	166	retVal = valueDelta * tickSpan;
	167
	168	if (retVal < 0.0)
	169	retVal = 0.0;
	170	}
	171	return retVal;
	172	}
	173
	174	QPointF LogXLogYPolarDomain::calculateDomainPoint(const QPointF &point) const
	175	{
	176	if (point == m_center)
	177	return QPointF(0.0, m_minY);
	178
	179	QLineF line(m_center, point);
	180	qreal a = 90.0 - line.angle();
	181	if (a < 0.0)
	182	a += 360.0;
	183
	184	const qreal deltaX = 360.0 / qAbs(m_logRightX - m_logLeftX);
	185	a = qPow(m_logBaseX, m_logLeftX + (a / deltaX));
	186
	187	const qreal deltaY = m_radius / qAbs(m_logOuterY - m_logInnerY);
	188	qreal r = qPow(m_logBaseY, m_logInnerY + (line.length() / deltaY));
	189
	190	return QPointF(a, r);
	191	}
	192
	193	bool LogXLogYPolarDomain::attachAxis(QAbstractAxis *axis)
	194	{
	195	AbstractDomain::attachAxis(axis);
	196	QLogValueAxis logAxis = qobject_cast<QLogValueAxis >(axis);
	197
	198	if (logAxis && logAxis->orientation() == Qt::Horizontal) {
	199	QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
	200	handleHorizontalAxisBaseChanged(logAxis->base());
	201	} else if (logAxis && logAxis->orientation() == Qt::Vertical){
	202	QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
	203	handleVerticalAxisBaseChanged(logAxis->base());
	204	}
	205
	206	return true;
	207	}
	208
	209	bool LogXLogYPolarDomain::detachAxis(QAbstractAxis *axis)
	210	{
	211	AbstractDomain::detachAxis(axis);
	212	QLogValueAxis logAxis = qobject_cast<QLogValueAxis >(axis);
	213
	214	if (logAxis && logAxis->orientation() == Qt::Horizontal)
	215	QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
	216	else if (logAxis && logAxis->orientation() == Qt::Vertical)
	217	QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
	218
	219	return true;
	220	}
	221
	222	void LogXLogYPolarDomain::handleHorizontalAxisBaseChanged(qreal baseX)
	223	{
	224	m_logBaseX = baseX;
	225	qreal logMinX = log10(m_minX) / log10(m_logBaseX);
	226	qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
	227	m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
	228	m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
	229	emit updated();
	230	}
	231
	232	void LogXLogYPolarDomain::handleVerticalAxisBaseChanged(qreal baseY)
	233	{
	234	m_logBaseY = baseY;
	235	qreal logMinY = log10(m_minY) / log10(m_logBaseY);
	236	qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
	237	m_logInnerY = logMinY < logMaxY ? logMinY : logMaxY;
	238	m_logOuterY = logMinY > logMaxY ? logMinY : logMaxY;
	239	emit updated();
	240	}
	241
	242	// operators
	243
	244	bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const LogXLogYPolarDomain &domain1, const LogXLogYPolarDomain &domain2)
	245	{
	246	return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX)
	247	&& qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY)
	248	&& qFuzzyIsNull(domain1.m_minX - domain2.m_minX)
	249	&& qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
	250	}
	251
	252
	253	bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const LogXLogYPolarDomain &domain1, const LogXLogYPolarDomain &domain2)
	254	{
	255	return !(domain1 == domain2);
	256	}
	257
	258
	259	QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXLogYPolarDomain &domain)
	260	{
	261	dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
	262	return dbg.maybeSpace();
	263	}
	264
	265	#include "moc_logxlogypolardomain_p.cpp"
	266
	267	QTCOMMERCIALCHART_END_NAMESPACE

src/domain/logxlogypolardomain_p.h created 644 +81 0

@@ -0,0 +1,81
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef LOGXLOGYPOLARDOMAIN_H
	31	#define LOGXLOGYPOLARDOMAIN_H
	32	#include "polardomain_p.h"
	33	#include <QRectF>
	34	#include <QSizeF>
	35
	36	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	37
	38	class QTCOMMERCIALCHART_AUTOTEST_EXPORT LogXLogYPolarDomain: public PolarDomain
	39	{
	40	Q_OBJECT
	41	public:
	42	explicit LogXLogYPolarDomain(QObject *object = 0);
	43	virtual ~LogXLogYPolarDomain();
	44
	45	DomainType type() { return AbstractDomain::LogXLogYPolarDomain; }
	46
	47	void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY);
	48
	49	friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const LogXLogYPolarDomain &domain1, const LogXLogYPolarDomain &domain2);
	50	friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const LogXLogYPolarDomain &domain1, const LogXLogYPolarDomain &domain2);
	51	friend QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXLogYPolarDomain &domain);
	52
	53	void zoomIn(const QRectF &rect);
	54	void zoomOut(const QRectF &rect);
	55	void move(qreal dx, qreal dy);
	56
	57	QPointF calculateDomainPoint(const QPointF &point) const;
	58
	59	bool attachAxis(QAbstractAxis *axis);
	60	bool detachAxis(QAbstractAxis *axis);
	61
	62	public Q_SLOTS:
	63	void handleVerticalAxisBaseChanged(qreal baseY);
	64	void handleHorizontalAxisBaseChanged(qreal baseX);
	65
	66	protected:
	67	qreal toAngularCoordinate(qreal value, bool &ok) const;
	68	qreal toRadialCoordinate(qreal value, bool &ok) const;
	69
	70	private:
	71	qreal m_logLeftX;
	72	qreal m_logRightX;
	73	qreal m_logBaseX;
	74	qreal m_logInnerY;
	75	qreal m_logOuterY;
	76	qreal m_logBaseY;
	77	};
	78
	79	QTCOMMERCIALCHART_END_NAMESPACE
	80
	81	#endif // LOGXLOGYPOLARDOMAIN_H

src/domain/logxypolardomain.cpp created 644 +236 0

@@ -0,0 +1,236
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "logxypolardomain_p.h"
	22	#include "qabstractaxis_p.h"
	23	#include "qlogvalueaxis.h"
	24	#include <qmath.h>
	25
	26	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	27
	28	LogXYPolarDomain::LogXYPolarDomain(QObject *parent)
	29	: PolarDomain(parent),
	30	m_logLeftX(0),
	31	m_logRightX(1),
	32	m_logBaseX(10)
	33	{
	34	}
	35
	36	LogXYPolarDomain::~LogXYPolarDomain()
	37	{
	38	}
	39
	40	void LogXYPolarDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
	41	{
	42	bool axisXChanged = false;
	43	bool axisYChanged = false;
	44
	45	adjustLogDomainRanges(minX, maxX);
	46
	47	if (!qFuzzyCompare(m_minX, minX) \|\| !qFuzzyCompare(m_maxX, maxX)) {
	48	m_minX = minX;
	49	m_maxX = maxX;
	50	axisXChanged = true;
	51	qreal logMinX = log10(m_minX) / log10(m_logBaseX);
	52	qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
	53	m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
	54	m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
	55	if (!m_signalsBlocked)
	56	emit rangeHorizontalChanged(m_minX, m_maxX);
	57	}
	58
	59	if (!qFuzzyIsNull(m_minY - minY) \|\| !qFuzzyIsNull(m_maxY - maxY)) {
	60	m_minY = minY;
	61	m_maxY = maxY;
	62	axisYChanged = true;
	63	if (!m_signalsBlocked)
	64	emit rangeVerticalChanged(m_minY, m_maxY);
	65	}
	66
	67	if (axisXChanged \|\| axisYChanged)
	68	emit updated();
	69	}
	70
	71	void LogXYPolarDomain::zoomIn(const QRectF &rect)
	72	{
	73	qreal logLeftX = rect.left() * (m_logRightX - m_logLeftX) / m_size.width() + m_logLeftX;
	74	qreal logRightX = rect.right() * (m_logRightX - m_logLeftX) / m_size.width() + m_logLeftX;
	75	qreal leftX = qPow(m_logBaseX, logLeftX);
	76	qreal rightX = qPow(m_logBaseX, logRightX);
	77	qreal minX = leftX < rightX ? leftX : rightX;
	78	qreal maxX = leftX > rightX ? leftX : rightX;
	79
	80	qreal dy = spanY() / m_size.height();
	81	qreal minY = m_minY;
	82	qreal maxY = m_maxY;
	83
	84	minY = maxY - dy * rect.bottom();
	85	maxY = maxY - dy * rect.top();
	86
	87	setRange(minX, maxX, minY, maxY);
	88	}
	89
	90	void LogXYPolarDomain::zoomOut(const QRectF &rect)
	91	{
	92	const qreal factorX = m_size.width() / rect.width();
	93
	94	qreal logLeftX = m_logLeftX + (m_logRightX - m_logLeftX) / 2.0 * (1.0 - factorX);
	95	qreal logRIghtX = m_logLeftX + (m_logRightX - m_logLeftX) / 2.0 * (1.0 + factorX);
	96	qreal leftX = qPow(m_logBaseX, logLeftX);
	97	qreal rightX = qPow(m_logBaseX, logRIghtX);
	98	qreal minX = leftX < rightX ? leftX : rightX;
	99	qreal maxX = leftX > rightX ? leftX : rightX;
	100
	101	qreal dy = spanY() / rect.height();
	102	qreal minY = m_minY;
	103	qreal maxY = m_maxY;
	104
	105	maxY = minY + dy * rect.bottom();
	106	minY = maxY - dy * m_size.height();
	107
	108	setRange(minX, maxX, minY, maxY);
	109	}
	110
	111	void LogXYPolarDomain::move(qreal dx, qreal dy)
	112	{
	113	qreal stepX = dx * (m_logRightX - m_logLeftX) / m_size.width();
	114	qreal leftX = qPow(m_logBaseX, m_logLeftX + stepX);
	115	qreal rightX = qPow(m_logBaseX, m_logRightX + stepX);
	116	qreal minX = leftX < rightX ? leftX : rightX;
	117	qreal maxX = leftX > rightX ? leftX : rightX;
	118
	119	qreal y = spanY() / m_radius;
	120	qreal minY = m_minY;
	121	qreal maxY = m_maxY;
	122
	123	if (dy != 0) {
	124	minY = minY + y * dy;
	125	maxY = maxY + y * dy;
	126	}
	127	setRange(minX, maxX, minY, maxY);
	128	}
	129
	130	qreal LogXYPolarDomain::toAngularCoordinate(qreal value, bool &ok) const
	131	{
	132	qreal retVal;
	133	if (value <= 0) {
	134	ok = false;
	135	retVal = 0.0;
	136	} else {
	137	ok = true;
	138	const qreal tickSpan = 360.0 / qAbs(m_logRightX - m_logLeftX);
	139	const qreal logValue = log10(value) / log10(m_logBaseX);
	140	const qreal valueDelta = logValue - m_logLeftX;
	141
	142	retVal = valueDelta * tickSpan;
	143	}
	144	return retVal;
	145	}
	146
	147	qreal LogXYPolarDomain::toRadialCoordinate(qreal value, bool &ok) const
	148	{
	149	ok = true;
	150	if (value < m_minY)
	151	value = m_minY;
	152
	153	// Dont limit the max. The drawing should clip the stuff that goes out of the grid
	154	qreal f = (value - m_minY) / (m_maxY - m_minY);
	155
	156	return f * m_radius;
	157	}
	158
	159	QPointF LogXYPolarDomain::calculateDomainPoint(const QPointF &point) const
	160	{
	161	if (point == m_center)
	162	return QPointF(0.0, m_minY);
	163
	164	QLineF line(m_center, point);
	165	qreal a = 90.0 - line.angle();
	166	if (a < 0.0)
	167	a += 360.0;
	168
	169	const qreal deltaX = 360.0 / qAbs(m_logRightX - m_logLeftX);
	170	a = qPow(m_logBaseX, m_logLeftX + (a / deltaX));
	171
	172	qreal r = m_minY + ((m_maxY - m_minY) * (line.length() / m_radius));
	173
	174	return QPointF(a, r);
	175	}
	176
	177	bool LogXYPolarDomain::attachAxis(QAbstractAxis *axis)
	178	{
	179	AbstractDomain::attachAxis(axis);
	180	QLogValueAxis logAxis = qobject_cast<QLogValueAxis >(axis);
	181
	182	if (logAxis && logAxis->orientation() == Qt::Horizontal) {
	183	QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
	184	handleHorizontalAxisBaseChanged(logAxis->base());
	185	}
	186
	187	return true;
	188	}
	189
	190	bool LogXYPolarDomain::detachAxis(QAbstractAxis *axis)
	191	{
	192	AbstractDomain::detachAxis(axis);
	193	QLogValueAxis logAxis = qobject_cast<QLogValueAxis >(axis);
	194
	195	if (logAxis && logAxis->orientation() == Qt::Horizontal)
	196	QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
	197
	198	return true;
	199	}
	200
	201	void LogXYPolarDomain::handleHorizontalAxisBaseChanged(qreal baseX)
	202	{
	203	m_logBaseX = baseX;
	204	qreal logMinX = log10(m_minX) / log10(m_logBaseX);
	205	qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
	206	m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
	207	m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
	208	emit updated();
	209	}
	210
	211	// operators
	212
	213	bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const LogXYPolarDomain &domain1, const LogXYPolarDomain &domain2)
	214	{
	215	return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX)
	216	&& qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY)
	217	&& qFuzzyIsNull(domain1.m_minX - domain2.m_minX)
	218	&& qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
	219	}
	220
	221
	222	bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const LogXYPolarDomain &domain1, const LogXYPolarDomain &domain2)
	223	{
	224	return !(domain1 == domain2);
	225	}
	226
	227
	228	QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXYPolarDomain &domain)
	229	{
	230	dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
	231	return dbg.maybeSpace();
	232	}
	233
	234	#include "moc_logxypolardomain_p.cpp"
	235
	236	QTCOMMERCIALCHART_END_NAMESPACE

src/domain/logxypolardomain_p.h created 644 +77 0

@@ -0,0 +1,77
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef LOGXYPOLARDOMAIN_H
	31	#define LOGXYPOLARDOMAIN_H
	32	#include "polardomain_p.h"
	33	#include <QRectF>
	34	#include <QSizeF>
	35
	36	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	37
	38	class QTCOMMERCIALCHART_AUTOTEST_EXPORT LogXYPolarDomain: public PolarDomain
	39	{
	40	Q_OBJECT
	41	public:
	42	explicit LogXYPolarDomain(QObject *object = 0);
	43	virtual ~LogXYPolarDomain();
	44
	45	DomainType type() { return AbstractDomain::LogXYPolarDomain; }
	46
	47	void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY);
	48
	49	friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const LogXYPolarDomain &domain1, const LogXYPolarDomain &domain2);
	50	friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const LogXYPolarDomain &domain1, const LogXYPolarDomain &domain2);
	51	friend QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXYPolarDomain &domain);
	52
	53	void zoomIn(const QRectF &rect);
	54	void zoomOut(const QRectF &rect);
	55	void move(qreal dx, qreal dy);
	56
	57	QPointF calculateDomainPoint(const QPointF &point) const;
	58
	59	bool attachAxis(QAbstractAxis *axis);
	60	bool detachAxis(QAbstractAxis *axis);
	61
	62	public Q_SLOTS:
	63	void handleHorizontalAxisBaseChanged(qreal baseX);
	64
	65	protected:
	66	qreal toAngularCoordinate(qreal value, bool &ok) const;
	67	qreal toRadialCoordinate(qreal value, bool &ok) const;
	68
	69	private:
	70	qreal m_logLeftX;
	71	qreal m_logRightX;
	72	qreal m_logBaseX;
	73	};
	74
	75	QTCOMMERCIALCHART_END_NAMESPACE
	76
	77	#endif // LOGXYPOLARDOMAIN_H

src/domain/polardomain.cpp created 644 +91 0

@@ -0,0 +1,91
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "polardomain_p.h"
	22	#include "qabstractaxis_p.h"
	23	#include <qmath.h>
	24
	25	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	26
	27	PolarDomain::PolarDomain(QObject *parent)
	28	: AbstractDomain(parent)
	29	{
	30	}
	31
	32	PolarDomain::~PolarDomain()
	33	{
	34	}
	35
	36	void PolarDomain::setSize(const QSizeF &size)
	37	{
	38	Q_ASSERT(size.width() == size.height());
	39	m_radius = size.height() / 2;
	40	m_center = QPointF(m_radius, m_radius);
	41	AbstractDomain::setSize(size);
	42	}
	43
	44	QPointF PolarDomain::calculateGeometryPoint(const QPointF &point, bool &ok) const
	45	{
	46	qreal r;
	47	qreal a = toAngularCoordinate(point.x(), ok);
	48	if (ok)
	49	r = toRadialCoordinate(point.y(), ok);
	50	if (ok) {
	51	return m_center + polarCoordinateToPoint(a, r);
	52	} else {
	53	qWarning() << "Logarithm of negative value is undefined. Empty layout returned.";
	54	return QPointF();
	55	}
	56	}
	57
	58	QVector<QPointF> PolarDomain::calculateGeometryPoints(const QList<QPointF> &vector) const
	59	{
	60	QVector<QPointF> result;
	61	result.resize(vector.count());
	62	bool ok;
	63	qreal r;
	64	qreal a;
	65
	66	for (int i = 0; i < vector.count(); ++i) {
	67	a = toAngularCoordinate(vector[i].x(), ok);
	68	if (ok)
	69	r = toRadialCoordinate(vector[i].y(), ok);
	70	if (ok) {
	71	result[i] = m_center + polarCoordinateToPoint(a, r);
	72	} else {
	73	qWarning() << "Logarithm of negative value is undefined. Empty layout returned.";
	74	return QVector<QPointF>();
	75	}
	76	}
	77
	78	return result;
	79	}
	80
	81	QPointF PolarDomain::polarCoordinateToPoint(qreal angularCoordinate, qreal radialCoordinate) const
	82	{
	83	qreal dx = qSin(angularCoordinate * (M_PI / 180)) * radialCoordinate;
	84	qreal dy = qCos(angularCoordinate * (M_PI / 180)) * radialCoordinate;
	85
	86	return QPointF(dx, -dy);
	87	}
	88
	89	#include "moc_polardomain_p.cpp"
	90
	91	QTCOMMERCIALCHART_END_NAMESPACE

src/domain/polardomain_p.h created 644 +62 0

@@ -0,0 +1,62
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef POLARDOMAIN_H
	31	#define POLARDOMAIN_H
	32	#include "abstractdomain_p.h"
	33	#include <QRectF>
	34	#include <QSizeF>
	35
	36	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	37
	38	class QTCOMMERCIALCHART_AUTOTEST_EXPORT PolarDomain: public AbstractDomain
	39	{
	40	Q_OBJECT
	41	public:
	42	explicit PolarDomain(QObject *object = 0);
	43	virtual ~PolarDomain();
	44
	45	void setSize(const QSizeF &size);
	46
	47	QPointF calculateGeometryPoint(const QPointF &point, bool &ok) const;
	48	QVector<QPointF> calculateGeometryPoints(const QList<QPointF> &vector) const;
	49
	50	virtual qreal toAngularCoordinate(qreal value, bool &ok) const = 0;
	51	virtual qreal toRadialCoordinate(qreal value, bool &ok) const = 0;
	52
	53	protected:
	54	QPointF polarCoordinateToPoint(qreal angularCoordinate, qreal radialCoordinate) const;
	55
	56	QPointF m_center;
	57	qreal m_radius;
	58	};
	59
	60	QTCOMMERCIALCHART_END_NAMESPACE
	61
	62	#endif // POLARDOMAIN_H

src/domain/xlogypolardomain.cpp created 644 +231 0

@@ -0,0 +1,231
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "xlogypolardomain_p.h"
	22	#include "qabstractaxis_p.h"
	23	#include "qlogvalueaxis.h"
	24	#include <qmath.h>
	25
	26	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	27
	28	XLogYPolarDomain::XLogYPolarDomain(QObject *parent)
	29	: PolarDomain(parent),
	30	m_logInnerY(0),
	31	m_logOuterY(1),
	32	m_logBaseY(10)
	33	{
	34	}
	35
	36	XLogYPolarDomain::~XLogYPolarDomain()
	37	{
	38	}
	39
	40	void XLogYPolarDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
	41	{
	42	bool axisXChanged = false;
	43	bool axisYChanged = false;
	44
	45	adjustLogDomainRanges(minY, maxY);
	46
	47	if (!qFuzzyIsNull(m_minX - minX) \|\| !qFuzzyIsNull(m_maxX - maxX)) {
	48	m_minX = minX;
	49	m_maxX = maxX;
	50	axisXChanged = true;
	51	if (!m_signalsBlocked)
	52	emit rangeHorizontalChanged(m_minX, m_maxX);
	53	}
	54
	55	if (!qFuzzyIsNull(m_minY - minY) \|\| !qFuzzyIsNull(m_maxY - maxY)) {
	56	m_minY = minY;
	57	m_maxY = maxY;
	58	axisYChanged = true;
	59	qreal logMinY = log10(m_minY) / log10(m_logBaseY);
	60	qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
	61	m_logInnerY = logMinY < logMaxY ? logMinY : logMaxY;
	62	m_logOuterY = logMinY > logMaxY ? logMinY : logMaxY;
	63	if (!m_signalsBlocked)
	64	emit rangeVerticalChanged(m_minY, m_maxY);
	65	}
	66
	67	if (axisXChanged \|\| axisYChanged)
	68	emit updated();
	69	}
	70
	71	void XLogYPolarDomain::zoomIn(const QRectF &rect)
	72	{
	73	qreal dx = spanX() / m_size.width();
	74	qreal maxX = m_maxX;
	75	qreal minX = m_minX;
	76
	77	maxX = minX + dx * rect.right();
	78	minX = minX + dx * rect.left();
	79
	80	qreal logLeftY = m_logOuterY - rect.bottom() * (m_logOuterY - m_logInnerY) / m_size.height();
	81	qreal logRightY = m_logOuterY - rect.top() * (m_logOuterY - m_logInnerY) / m_size.height();
	82	qreal leftY = qPow(m_logBaseY, logLeftY);
	83	qreal rightY = qPow(m_logBaseY, logRightY);
	84	qreal minY = leftY < rightY ? leftY : rightY;
	85	qreal maxY = leftY > rightY ? leftY : rightY;
	86
	87	setRange(minX, maxX, minY, maxY);
	88	}
	89
	90	void XLogYPolarDomain::zoomOut(const QRectF &rect)
	91	{
	92	qreal dx = spanX() / rect.width();
	93	qreal maxX = m_maxX;
	94	qreal minX = m_minX;
	95
	96	minX = maxX - dx * rect.right();
	97	maxX = minX + dx * m_size.width();
	98
	99	const qreal factorY = m_size.height() / rect.height();
	100	qreal newLogMinY = m_logInnerY + (m_logOuterY - m_logInnerY) / 2.0 * (1.0 - factorY);
	101	qreal newLogMaxY = m_logInnerY + (m_logOuterY - m_logInnerY) / 2.0 * (1.0 + factorY);
	102	qreal leftY = qPow(m_logBaseY, newLogMinY);
	103	qreal rightY = qPow(m_logBaseY, newLogMaxY);
	104	qreal minY = leftY < rightY ? leftY : rightY;
	105	qreal maxY = leftY > rightY ? leftY : rightY;
	106
	107	setRange(minX, maxX, minY, maxY);
	108	}
	109
	110	void XLogYPolarDomain::move(qreal dx, qreal dy)
	111	{
	112	qreal x = spanX() / 360.0;
	113
	114	qreal maxX = m_maxX;
	115	qreal minX = m_minX;
	116
	117	if (dx != 0) {
	118	minX = minX + x * dx;
	119	maxX = maxX + x * dx;
	120	}
	121
	122	qreal stepY = dy * (m_logOuterY - m_logInnerY) / m_radius;
	123	qreal leftY = qPow(m_logBaseY, m_logInnerY + stepY);
	124	qreal rightY = qPow(m_logBaseY, m_logOuterY + stepY);
	125	qreal minY = leftY < rightY ? leftY : rightY;
	126	qreal maxY = leftY > rightY ? leftY : rightY;
	127
	128	setRange(minX, maxX, minY, maxY);
	129	}
	130
	131	qreal XLogYPolarDomain::toAngularCoordinate(qreal value, bool &ok) const
	132	{
	133	ok = true;
	134	qreal f = (value - m_minX) / (m_maxX - m_minX);
	135	return f * 360.0;
	136	}
	137
	138	qreal XLogYPolarDomain::toRadialCoordinate(qreal value, bool &ok) const
	139	{
	140	qreal retVal;
	141	if (value <= 0) {
	142	ok = false;
	143	retVal = 0.0;
	144	} else {
	145	ok = true;
	146	const qreal tickSpan = m_radius / qAbs(m_logOuterY - m_logInnerY);
	147	const qreal logValue = log10(value) / log10(m_logBaseY);
	148	const qreal valueDelta = logValue - m_logInnerY;
	149
	150	retVal = valueDelta * tickSpan;
	151
	152	if (retVal < 0.0)
	153	retVal = 0.0;
	154	}
	155	return retVal;
	156	}
	157
	158	QPointF XLogYPolarDomain::calculateDomainPoint(const QPointF &point) const
	159	{
	160	if (point == m_center)
	161	return QPointF(0.0, m_minY);
	162
	163	QLineF line(m_center, point);
	164	qreal a = 90.0 - line.angle();
	165	if (a < 0.0)
	166	a += 360.0;
	167	a = ((a / 360.0) * (m_maxX - m_minX)) + m_minX;
	168
	169	const qreal deltaY = m_radius / qAbs(m_logOuterY - m_logInnerY);
	170	qreal r = qPow(m_logBaseY, m_logInnerY + (line.length() / deltaY));
	171
	172	return QPointF(a, r);
	173	}
	174
	175	bool XLogYPolarDomain::attachAxis(QAbstractAxis *axis)
	176	{
	177	QLogValueAxis logAxis = qobject_cast<QLogValueAxis >(axis);
	178
	179	if (logAxis && logAxis->orientation() == Qt::Vertical) {
	180	QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
	181	handleVerticalAxisBaseChanged(logAxis->base());
	182	}
	183	return AbstractDomain::attachAxis(axis);
	184	}
	185
	186	bool XLogYPolarDomain::detachAxis(QAbstractAxis *axis)
	187	{
	188	QLogValueAxis logAxis = qobject_cast<QLogValueAxis >(axis);
	189
	190	if (logAxis && logAxis->orientation() == Qt::Vertical)
	191	QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
	192
	193	return AbstractDomain::detachAxis(axis);
	194	}
	195
	196	void XLogYPolarDomain::handleVerticalAxisBaseChanged(qreal baseY)
	197	{
	198	m_logBaseY = baseY;
	199	qreal logMinY = log10(m_minY) / log10(m_logBaseY);
	200	qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
	201	m_logInnerY = logMinY < logMaxY ? logMinY : logMaxY;
	202	m_logOuterY = logMinY > logMaxY ? logMinY : logMaxY;
	203	emit updated();
	204	}
	205
	206	// operators
	207
	208	bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const XLogYPolarDomain &domain1, const XLogYPolarDomain &domain2)
	209	{
	210	return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX)
	211	&& qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY)
	212	&& qFuzzyIsNull(domain1.m_minX - domain2.m_minX)
	213	&& qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
	214	}
	215
	216
	217	bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const XLogYPolarDomain &domain1, const XLogYPolarDomain &domain2)
	218	{
	219	return !(domain1 == domain2);
	220	}
	221
	222
	223	QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const XLogYPolarDomain &domain)
	224	{
	225	dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
	226	return dbg.maybeSpace();
	227	}
	228
	229	#include "moc_xlogypolardomain_p.cpp"
	230
	231	QTCOMMERCIALCHART_END_NAMESPACE

src/domain/xlogypolardomain_p.h created 644 +77 0

@@ -0,0 +1,77
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef XLOGYPOLARDOMAIN_H
	31	#define XLOGYPOLARDOMAIN_H
	32	#include "polardomain_p.h"
	33	#include <QRectF>
	34	#include <QSizeF>
	35
	36	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	37
	38	class QTCOMMERCIALCHART_AUTOTEST_EXPORT XLogYPolarDomain: public PolarDomain
	39	{
	40	Q_OBJECT
	41	public:
	42	explicit XLogYPolarDomain(QObject *object = 0);
	43	virtual ~XLogYPolarDomain();
	44
	45	DomainType type() { return AbstractDomain::XLogYPolarDomain; }
	46
	47	void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY);
	48
	49	friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const XLogYPolarDomain &domain1, const XLogYPolarDomain &domain2);
	50	friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const XLogYPolarDomain &domain1, const XLogYPolarDomain &domain2);
	51	friend QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const XLogYPolarDomain &domain);
	52
	53	void zoomIn(const QRectF &rect);
	54	void zoomOut(const QRectF &rect);
	55	void move(qreal dx, qreal dy);
	56
	57	QPointF calculateDomainPoint(const QPointF &point) const;
	58
	59	bool attachAxis(QAbstractAxis *axis);
	60	bool detachAxis(QAbstractAxis *axis);
	61
	62	public Q_SLOTS:
	63	void handleVerticalAxisBaseChanged(qreal baseY);
	64
	65	protected:
	66	qreal toAngularCoordinate(qreal value, bool &ok) const;
	67	qreal toRadialCoordinate(qreal value, bool &ok) const;
	68
	69	private:
	70	qreal m_logInnerY;
	71	qreal m_logOuterY;
	72	qreal m_logBaseY;
	73	};
	74
	75	QTCOMMERCIALCHART_END_NAMESPACE
	76
	77	#endif // XLOGYPOLARDOMAIN_H

src/domain/xypolardomain.cpp created 644 +178 0

@@ -0,0 +1,178
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "xypolardomain_p.h"
	22	#include "qabstractaxis_p.h"
	23	#include <qmath.h>
	24
	25	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	26
	27	XYPolarDomain::XYPolarDomain(QObject *parent)
	28	: PolarDomain(parent)
	29	{
	30	}
	31
	32	XYPolarDomain::~XYPolarDomain()
	33	{
	34	}
	35
	36	void XYPolarDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
	37	{
	38	bool axisXChanged = false;
	39	bool axisYChanged = false;
	40
	41	if (!qFuzzyCompare(m_minX, minX) \|\| !qFuzzyCompare(m_maxX, maxX)) {
	42	m_minX = minX;
	43	m_maxX = maxX;
	44	axisXChanged = true;
	45	if (!m_signalsBlocked)
	46	emit rangeHorizontalChanged(m_minX, m_maxX);
	47	}
	48
	49	if (!qFuzzyCompare(m_minY, minY) \|\| !qFuzzyCompare(m_maxY, maxY)) {
	50	m_minY = minY;
	51	m_maxY = maxY;
	52	axisYChanged = true;
	53	if (!m_signalsBlocked)
	54	emit rangeVerticalChanged(m_minY, m_maxY);
	55	}
	56
	57	if (axisXChanged \|\| axisYChanged)
	58	emit updated();
	59	}
	60
	61
	62	void XYPolarDomain::zoomIn(const QRectF &rect)
	63	{
	64	qreal dx = spanX() / m_size.width();
	65	qreal dy = spanY() / m_size.height();
	66
	67	qreal maxX = m_maxX;
	68	qreal minX = m_minX;
	69	qreal minY = m_minY;
	70	qreal maxY = m_maxY;
	71
	72	maxX = minX + dx * rect.right();
	73	minX = minX + dx * rect.left();
	74	minY = maxY - dy * rect.bottom();
	75	maxY = maxY - dy * rect.top();
	76
	77	setRange(minX, maxX, minY, maxY);
	78	}
	79
	80	void XYPolarDomain::zoomOut(const QRectF &rect)
	81	{
	82	qreal dx = spanX() / rect.width();
	83	qreal dy = spanY() / rect.height();
	84
	85	qreal maxX = m_maxX;
	86	qreal minX = m_minX;
	87	qreal minY = m_minY;
	88	qreal maxY = m_maxY;
	89
	90	minX = maxX - dx * rect.right();
	91	maxX = minX + dx * m_size.width();
	92	maxY = minY + dy * rect.bottom();
	93	minY = maxY - dy * m_size.height();
	94
	95	setRange(minX, maxX, minY, maxY);
	96	}
	97
	98	void XYPolarDomain::move(qreal dx, qreal dy)
	99	{
	100	// One unit scrolls one degree angular and one pixel radial
	101	qreal x = spanX() / 360.0;
	102	qreal y = spanY() / m_radius;
	103
	104	qreal maxX = m_maxX;
	105	qreal minX = m_minX;
	106	qreal minY = m_minY;
	107	qreal maxY = m_maxY;
	108
	109	if (dx != 0) {
	110	minX = minX + x * dx;
	111	maxX = maxX + x * dx;
	112	}
	113	if (dy != 0) {
	114	minY = minY + y * dy;
	115	maxY = maxY + y * dy;
	116	}
	117	setRange(minX, maxX, minY, maxY);
	118	}
	119
	120	QPointF XYPolarDomain::calculateDomainPoint(const QPointF &point) const
	121	{
	122	if (point == m_center)
	123	return QPointF(0.0, m_minX);
	124
	125	QLineF line(m_center, point);
	126	qreal a = 90.0 - line.angle();
	127	if (a < 0.0)
	128	a += 360.0;
	129	a = ((a / 360.0) * (m_maxX - m_minX)) + m_minX;
	130	qreal r = m_minY + ((m_maxY - m_minY) * (line.length() / m_radius));
	131	return QPointF(a, r);
	132	}
	133
	134	qreal XYPolarDomain::toAngularCoordinate(qreal value, bool &ok) const
	135	{
	136	ok = true;
	137	qreal f = (value - m_minX) / (m_maxX - m_minX);
	138	return f * 360.0;
	139	}
	140
	141	qreal XYPolarDomain::toRadialCoordinate(qreal value, bool &ok) const
	142	{
	143	ok = true;
	144	if (value < m_minY)
	145	value = m_minY;
	146
	147	// Dont limit the max. The drawing should clip the stuff that goes out of the grid
	148	qreal f = (value - m_minY) / (m_maxY - m_minY);
	149
	150	return f * m_radius;
	151	}
	152
	153	// operators
	154
	155	bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const XYPolarDomain &domain1, const XYPolarDomain &domain2)
	156	{
	157	return (qFuzzyCompare(domain1.m_maxX, domain2.m_maxX)
	158	&& qFuzzyCompare(domain1.m_maxY, domain2.m_maxY)
	159	&& qFuzzyCompare(domain1.m_minX, domain2.m_minX)
	160	&& qFuzzyCompare(domain1.m_minY, domain2.m_minY));
	161	}
	162
	163
	164	bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const XYPolarDomain &domain1, const XYPolarDomain &domain2)
	165	{
	166	return !(domain1 == domain2);
	167	}
	168
	169
	170	QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const XYPolarDomain &domain)
	171	{
	172	dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
	173	return dbg.maybeSpace();
	174	}
	175
	176	#include "moc_xypolardomain_p.cpp"
	177
	178	QTCOMMERCIALCHART_END_NAMESPACE

src/domain/xypolardomain_p.h created 644 +65 0

@@ -0,0 +1,65
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef XYPOLARDOMAIN_H
	31	#define XYPOLARDOMAIN_H
	32	#include "polardomain_p.h"
	33	#include <QRectF>
	34
	35	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	36
	37	class QTCOMMERCIALCHART_AUTOTEST_EXPORT XYPolarDomain: public PolarDomain
	38	{
	39	Q_OBJECT
	40	public:
	41	explicit XYPolarDomain(QObject *object = 0);
	42	virtual ~XYPolarDomain();
	43
	44	DomainType type(){ return AbstractDomain::XYPolarDomain;}
	45
	46	void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY);
	47
	48	friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const XYPolarDomain &Domain1, const XYPolarDomain &Domain2);
	49	friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const XYPolarDomain &Domain1, const XYPolarDomain &Domain2);
	50	friend QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const XYPolarDomain &AbstractDomain);
	51
	52	void zoomIn(const QRectF &rect);
	53	void zoomOut(const QRectF &rect);
	54	void move(qreal dx, qreal dy);
	55
	56	QPointF calculateDomainPoint(const QPointF &point) const;
	57
	58	protected:
	59	qreal toAngularCoordinate(qreal value, bool &ok) const;
	60	qreal toRadialCoordinate(qreal value, bool &ok) const;
	61	};
	62
	63	QTCOMMERCIALCHART_END_NAMESPACE
	64
	65	#endif // XYPOLARDOMAIN_H

src/layout/abstractchartlayout.cpp created 644 +197 0

@@ -0,0 +1,197
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "abstractchartlayout_p.h"
	22	#include "chartpresenter_p.h"
	23	#include "qlegend_p.h"
	24	#include "chartaxiselement_p.h"
	25	#include "charttitle_p.h"
	26	#include "chartbackground_p.h"
	27	#include <QDebug>
	28
	29	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	30
	31	static const qreal golden_ratio = 0.4;
	32
	33	AbstractChartLayout::AbstractChartLayout(ChartPresenter *presenter)
	34	: m_presenter(presenter),
	35	m_margins(20, 20, 20, 20),
	36	m_minChartRect(0, 0, 200, 200)
	37	{
	38	}
	39
	40	AbstractChartLayout::~AbstractChartLayout()
	41	{
	42	}
	43
	44	void AbstractChartLayout::setGeometry(const QRectF &rect)
	45	{
	46	if (!rect.isValid())
	47	return;
	48
	49	QList<ChartAxisElement *> axes = m_presenter->axisItems();
	50	ChartTitle *title = m_presenter->titleElement();
	51	QLegend *legend = m_presenter->legend();
	52	ChartBackground *background = m_presenter->backgroundElement();
	53
	54	QRectF contentGeometry = calculateBackgroundGeometry(rect, background);
	55
	56	contentGeometry = calculateContentGeometry(contentGeometry);
	57
	58	if (title && title->isVisible())
	59	contentGeometry = calculateTitleGeometry(contentGeometry, title);
	60
	61	if (legend->isAttachedToChart() && legend->isVisible())
	62	contentGeometry = calculateLegendGeometry(contentGeometry, legend);
	63
	64	contentGeometry = calculateAxisGeometry(contentGeometry, axes);
	65
	66	m_presenter->setGeometry(contentGeometry);
	67
	68	QGraphicsLayout::setGeometry(rect);
	69	}
	70
	71	QRectF AbstractChartLayout::calculateContentGeometry(const QRectF &geometry) const
	72	{
	73	return geometry.adjusted(m_margins.left(), m_margins.top(), -m_margins.right(), -m_margins.bottom());
	74	}
	75
	76	QRectF AbstractChartLayout::calculateContentMinimum(const QRectF &minimum) const
	77	{
	78	return minimum.adjusted(0, 0, m_margins.left() + m_margins.right(), m_margins.top() + m_margins.bottom());
	79	}
	80
	81
	82	QRectF AbstractChartLayout::calculateBackgroundGeometry(const QRectF &geometry, ChartBackground *background) const
	83	{
	84	qreal left;
	85	qreal top;
	86	qreal right;
	87	qreal bottom;
	88	getContentsMargins(&left, &top, &right, &bottom);
	89	QRectF backgroundGeometry = geometry.adjusted(left, top, -right, -bottom);
	90	if (background)
	91	background->setRect(backgroundGeometry);
	92	return backgroundGeometry;
	93	}
	94
	95	QRectF AbstractChartLayout::calculateBackgroundMinimum(const QRectF &minimum) const
	96	{
	97	qreal left;
	98	qreal top;
	99	qreal right;
	100	qreal bottom;
	101	getContentsMargins(&left, &top, &right, &bottom);
	102	return minimum.adjusted(0, 0, left + right, top + bottom);
	103	}
	104
	105	QRectF AbstractChartLayout::calculateLegendGeometry(const QRectF &geometry, QLegend *legend) const
	106	{
	107	QSizeF size = legend->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, -1));
	108	QRectF legendRect;
	109	QRectF result;
	110
	111	switch (legend->alignment()) {
	112	case Qt::AlignTop: {
	113	legendRect = QRectF(geometry.topLeft(), QSizeF(geometry.width(), size.height()));
	114	result = geometry.adjusted(0, legendRect.height(), 0, 0);
	115	break;
	116	}
	117	case Qt::AlignBottom: {
	118	legendRect = QRectF(QPointF(geometry.left(), geometry.bottom() - size.height()), QSizeF(geometry.width(), size.height()));
	119	result = geometry.adjusted(0, 0, 0, -legendRect.height());
	120	break;
	121	}
	122	case Qt::AlignLeft: {
	123	qreal width = qMin(size.width(), geometry.width() * golden_ratio);
	124	legendRect = QRectF(geometry.topLeft(), QSizeF(width, geometry.height()));
	125	result = geometry.adjusted(width, 0, 0, 0);
	126	break;
	127	}
	128	case Qt::AlignRight: {
	129	qreal width = qMin(size.width(), geometry.width() * golden_ratio);
	130	legendRect = QRectF(QPointF(geometry.right() - width, geometry.top()), QSizeF(width, geometry.height()));
	131	result = geometry.adjusted(0, 0, -width, 0);
	132	break;
	133	}
	134	default: {
	135	legendRect = QRectF(0, 0, 0, 0);
	136	result = geometry;
	137	break;
	138	}
	139	}
	140
	141	legend->setGeometry(legendRect);
	142
	143	return result;
	144	}
	145
	146	QRectF AbstractChartLayout::calculateLegendMinimum(const QRectF &geometry, QLegend *legend) const
	147	{
	148	QSizeF minSize = legend->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, -1));
	149	return geometry.adjusted(0, 0, minSize.width(), minSize.height());
	150	}
	151
	152	QRectF AbstractChartLayout::calculateTitleGeometry(const QRectF &geometry, ChartTitle *title) const
	153	{
	154	title->setGeometry(geometry);
	155	QPointF center = geometry.center() - title->boundingRect().center();
	156	title->setPos(center.x(), title->pos().y());
	157	return geometry.adjusted(0, title->boundingRect().height()+1, 0, 0);
	158	}
	159
	160	QRectF AbstractChartLayout::calculateTitleMinimum(const QRectF &minimum, ChartTitle *title) const
	161	{
	162	QSizeF min = title->sizeHint(Qt::MinimumSize);
	163	return minimum.adjusted(0, 0, min.width(), min.height());
	164	}
	165
	166	QSizeF AbstractChartLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
	167	{
	168	Q_UNUSED(constraint);
	169	if (which == Qt::MinimumSize) {
	170	QList<ChartAxisElement *> axes = m_presenter->axisItems();
	171	ChartTitle *title = m_presenter->titleElement();
	172	QLegend *legend = m_presenter->legend();
	173	QRectF minimumRect(0, 0, 0, 0);
	174	minimumRect = calculateBackgroundMinimum(minimumRect);
	175	minimumRect = calculateContentMinimum(minimumRect);
	176	minimumRect = calculateTitleMinimum(minimumRect, title);
	177	minimumRect = calculateLegendMinimum(minimumRect, legend);
	178	minimumRect = calculateAxisMinimum(minimumRect, axes);
	179	return minimumRect.united(m_minChartRect).size().toSize();
	180	}
	181	return QSize(-1, -1);
	182	}
	183
	184	void AbstractChartLayout::setMargins(const QMargins &margins)
	185	{
	186	if (m_margins != margins) {
	187	m_margins = margins;
	188	updateGeometry();
	189	}
	190	}
	191
	192	QMargins AbstractChartLayout::margins() const
	193	{
	194	return m_margins;
	195	}
	196
	197	QTCOMMERCIALCHART_END_NAMESPACE

src/layout/cartesianchartlayout_p.h created 644 +50 0

@@ -0,0 +1,50
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef CARTESIANCHARTLAYOUT_H
	31	#define CARTESIANCHARTLAYOUT_H
	32
	33	#include "abstractchartlayout_p.h"
	34
	35	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	36
	37	class CartesianChartLayout : public AbstractChartLayout
	38	{
	39	public:
	40	CartesianChartLayout(ChartPresenter *presenter);
	41	virtual ~CartesianChartLayout();
	42
	43	// from AbstractChartLayout
	44	QRectF calculateAxisMinimum(const QRectF &minimum, const QList<ChartAxisElement *> &axes) const;
	45	QRectF calculateAxisGeometry(const QRectF &geometry, const QList<ChartAxisElement *> &axes) const;
	46	};
	47
	48	QTCOMMERCIALCHART_END_NAMESPACE
	49
	50	#endif // CARTESIANCHARTLAYOUT_H

src/layout/layout.pri created 644 +12 0

@@ -0,0 +1,12
	1	INCLUDEPATH += $$PWD
	2	DEPENDPATH += $$PWD
	3
	4	SOURCES += \
	5	$$PWD/abstractchartlayout.cpp \
	6	$$PWD/cartesianchartlayout.cpp \
	7	$$PWD/polarchartlayout.cpp
	8
	9	PRIVATE_HEADERS += \
	10	$$PWD/abstractchartlayout_p.h \
	11	$$PWD/cartesianchartlayout_p.h \
	12	$$PWD/polarchartlayout_p.h

src/layout/polarchartlayout.cpp created 644 +83 0

@@ -0,0 +1,83
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "polarchartlayout_p.h"
	22	#include "chartpresenter_p.h"
	23	#include "polarchartaxis_p.h"
	24	#include <QDebug>
	25	#include <QFontMetrics>
	26
	27	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	28
	29	static const qreal golden_ratio = 0.4;
	30
	31	PolarChartLayout::PolarChartLayout(ChartPresenter *presenter)
	32	: AbstractChartLayout(presenter)
	33	{
	34	}
	35
	36	PolarChartLayout::~PolarChartLayout()
	37	{
	38	}
	39
	40	QRectF PolarChartLayout::calculateAxisGeometry(const QRectF &geometry, const QList<ChartAxisElement *> &axes) const
	41	{
	42	// How to handle multiple angular/radial axes?
	43	qreal axisRadius = geometry.height() / 2.0;
	44	if (geometry.width() < geometry.height())
	45	axisRadius = geometry.width() / 2.0;
	46
	47	int titleHeight = 0;
	48	foreach (ChartAxisElement *chartAxis, axes) {
	49	if (!chartAxis->isVisible())
	50	continue;
	51
	52	PolarChartAxis polarChartAxis = static_cast<PolarChartAxis >(chartAxis);
	53	qreal radius = polarChartAxis->preferredAxisRadius(geometry.size());
	54	if (radius < axisRadius)
	55	axisRadius = radius;
	56
	57	if (chartAxis->axis()->orientation() == Qt::Horizontal
	58	&& chartAxis->axis()->isTitleVisible()
	59	&& !chartAxis->axis()->titleText().isEmpty()) {
	60	// If axis has angular title, adjust geometry down by the space title takes
	61	QFontMetrics titleMetrics(chartAxis->axis()->titleFont());
	62	titleHeight = (titleMetrics.boundingRect(chartAxis->axis()->titleText()).height() / 2) + chartAxis->titlePadding();
	63	}
	64	}
	65
	66	QRectF axisRect;
	67	axisRect.setSize(QSizeF(axisRadius * 2.0, axisRadius * 2.0));
	68	axisRect.moveCenter(geometry.center());
	69	axisRect.adjust(0, titleHeight, 0, titleHeight);
	70
	71	foreach (ChartAxisElement *chartAxis, axes)
	72	chartAxis->setGeometry(axisRect, QRectF());
	73
	74	return axisRect;
	75	}
	76
	77	QRectF PolarChartLayout::calculateAxisMinimum(const QRectF &minimum, const QList<ChartAxisElement *> &axes) const
	78	{
	79	Q_UNUSED(axes);
	80	return minimum;
	81	}
	82
	83	QTCOMMERCIALCHART_END_NAMESPACE

src/layout/polarchartlayout_p.h created 644 +50 0

@@ -0,0 +1,50
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef POLARCHARTLAYOUT_H
	31	#define POLARCHARTLAYOUT_H
	32
	33	#include "abstractchartlayout_p.h"
	34
	35	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	36
	37	class PolarChartLayout : public AbstractChartLayout
	38	{
	39	public:
	40	PolarChartLayout(ChartPresenter *presenter);
	41	virtual ~PolarChartLayout();
	42
	43	// from AbstractChartLayout
	44	QRectF calculateAxisMinimum(const QRectF &minimum, const QList<ChartAxisElement *> &axes) const;
	45	QRectF calculateAxisGeometry(const QRectF &geometry, const QList<ChartAxisElement *> &axes) const;
	46	};
	47
	48	QTCOMMERCIALCHART_END_NAMESPACE
	49
	50	#endif // POLARCHARTLAYOUT_H

src/qpolarchart.cpp created 644 +126 0

@@ -0,0 +1,126
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "qpolarchart.h"
	22	#include "qabstractaxis.h"
	23
	24	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	25
	26	/*!
	27	\enum QPolarChart::PolarOrientation
	28
	29	This type is used to signify the polar orientation of an axis.
	30
	31	\value PolarOrientationRadial
	32	\value PolarOrientationAngular
	33	*/
	34
	35	/*!
	36	\class QPolarChart
	37	\brief QtCommercial chart API.
	38
	39	QPolarChart is a specialization of QChart to show a polar chart.
	40
	41	Polar charts support line, spline, area, and scatter series, and all axis types
	42	supported by those series.
	43
	44	\note When setting ticks to an angular QValueAxis, keep in mind that the first and last tick
	45	are co-located at 0/360 degree angle.
	46
	47	\note If the angular distance between two consecutive points in a series is more than 180 degrees,
	48	any line connecting the two points becomes meaningless, so choose the axis ranges accordingly
	49	when displaying line, spline, or area series.
	50
	51	\note Polar charts do not support multiple axes of same orientation.
	52
	53	\sa QChart
	54	*/
	55
	56	/*!
	57	Constructs a polar chart as a child of a \a parent.
	58	Parameter \a wFlags is passed to the QChart constructor.
	59	*/
	60	QPolarChart::QPolarChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
	61	: QChart(QChart::ChartTypePolar, parent, wFlags)
	62	{
	63	}
	64
	65	/*!
	66	Destroys the object and it's children, like series and axis objects added to it.
	67	*/
	68	QPolarChart::~QPolarChart()
	69	{
	70	}
	71
	72	/*!
	73	Returns the axes added for the \a series with \a polarOrientation. If no series is provided, then any axis with the
	74	specified polar orientation is returned.
	75	\sa addAxis()
	76	*/
	77	QList<QAbstractAxis > QPolarChart::axes(PolarOrientations polarOrientation, QAbstractSeries series) const
	78	{
	79	Qt::Orientations orientation(0);
	80	if (polarOrientation.testFlag(PolarOrientationAngular))
	81	orientation \|= Qt::Horizontal;
	82	if (polarOrientation.testFlag(PolarOrientationRadial))
	83	orientation \|= Qt::Vertical;
	84
	85	return QChart::axes(orientation, series);
	86	}
	87
	88	/*!
	89	This convenience method adds \a axis to the polar chart with \a polarOrientation.
	90	The chart takes the ownership of the axis.
	91
	92	\note Axes can be added to a polar chart also with QChart::addAxis() instead of this method.
	93	The specified alignment determines the polar orientation: horizontal alignments indicate angular
	94	axis and vertical alignments indicate radial axis.
	95	\sa QChart::removeAxis(), QChart::createDefaultAxes(), QAbstractSeries::attachAxis(), QChart::addAxis()
	96	*/
	97	void QPolarChart::addAxis(QAbstractAxis *axis, PolarOrientation polarOrientation)
	98	{
	99	if (!axis \|\| axis->type() == QAbstractAxis::AxisTypeBarCategory) {
	100	qWarning("QAbstractAxis::AxisTypeBarCategory is not a supported axis type for polar charts.");
	101	} else {
	102	Qt::Alignment alignment = Qt::AlignLeft;
	103	if (polarOrientation == PolarOrientationAngular)
	104	alignment = Qt::AlignBottom;
	105	QChart::addAxis(axis, alignment);
	106	}
	107	}
	108
	109	/*!
	110	Angular axes of a polar chart report horizontal orientation and radial axes report
	111	vertical orientation.
	112	This function is a convenience function for converting the orientation of an \a axis to
	113	corresponding polar orientation. If the \a axis is NULL or not added to a polar chart,
	114	the return value is meaningless.
	115	*/
	116	QPolarChart::PolarOrientation QPolarChart::axisPolarOrientation(QAbstractAxis *axis)
	117	{
	118	if (axis && axis->orientation() == Qt::Horizontal)
	119	return PolarOrientationAngular;
	120	else
	121	return PolarOrientationRadial;
	122	}
	123
	124	#include "moc_qpolarchart.cpp"
	125
	126	QTCOMMERCIALCHART_END_NAMESPACE

src/qpolarchart.h created 644 +60 0

@@ -0,0 +1,60
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#ifndef QPOLARCHART_H
	22	#define QPOLARCHART_H
	23
	24	#include "qchart.h"
	25
	26	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	27
	28	class QAbstractSeries;
	29	class QAbstractAxis;
	30
	31	class QTCOMMERCIALCHART_EXPORT QPolarChart : public QChart
	32	{
	33	Q_OBJECT
	34	Q_ENUMS(PolarOrientation)
	35	Q_FLAGS(PolarOrientations)
	36
	37	public:
	38	enum PolarOrientation {
	39	PolarOrientationRadial = 0x1,
	40	PolarOrientationAngular = 0x2
	41	};
	42	Q_DECLARE_FLAGS(PolarOrientations, PolarOrientation)
	43
	44	public:
	45	explicit QPolarChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
	46	~QPolarChart();
	47
	48	void addAxis(QAbstractAxis *axis, PolarOrientation polarOrientation);
	49
	50	QList<QAbstractAxis> axes(PolarOrientations polarOrientation = PolarOrientations(PolarOrientationRadial \| PolarOrientationAngular), QAbstractSeries series = 0) const;
	51
	52	static PolarOrientation axisPolarOrientation(QAbstractAxis *axis);
	53
	54	protected:
	55	Q_DISABLE_COPY(QPolarChart)
	56	};
	57
	58	QTCOMMERCIALCHART_END_NAMESPACE
	59
	60	#endif // QCHART_H

tests/auto/README created 644 +9 0

@@ -0,0 +1,9
	1	Testing polar chart:
	2
	3	Since the tests typically initialize the chart once for the whole test case,
	4	it is difficult to test the components against polar chart unless all tests
	5	are duplicated or massively refactored. Neither option is desirable, so instead
	6	we check environment variable TEST_POLAR_CHART. If it is not empty, we run
	7	the tests that are relevant for polar chart against polar chart. Unfortunately
	8	This means two runs of the tests with different environment are required for
	9	full coverage.

tests/polarcharttest/chartview.cpp created 644 +58 0

@@ -0,0 +1,58
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "chartview.h"
	22	#include <QMouseEvent>
	23	#include <QDebug>
	24	#include <QAbstractAxis>
	25
	26	QTCOMMERCIALCHART_USE_NAMESPACE
	27
	28	ChartView::ChartView(QWidget *parent) :
	29	QChartView(parent)
	30	{
	31	}
	32
	33	void ChartView::keyPressEvent(QKeyEvent *event)
	34	{
	35	switch (event->key()) {
	36	case Qt::Key_Plus:
	37	chart()->zoomIn();
	38	break;
	39	case Qt::Key_Minus:
	40	chart()->zoomOut();
	41	break;
	42	case Qt::Key_Left:
	43	chart()->scroll(-1.0, 0);
	44	break;
	45	case Qt::Key_Right:
	46	chart()->scroll(1.0, 0);
	47	break;
	48	case Qt::Key_Up:
	49	chart()->scroll(0, 1.0);
	50	break;
	51	case Qt::Key_Down:
	52	chart()->scroll(0, -1.0);
	53	break;
	54	default:
	55	QGraphicsView::keyPressEvent(event);
	56	break;
	57	}
	58	}

tests/polarcharttest/chartview.h created 644 +38 0

@@ -0,0 +1,38
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#ifndef CHARTVIEW_H
	22	#define CHARTVIEW_H
	23
	24	#include <QChartView>
	25	#include <QPolarChart>
	26
	27	QTCOMMERCIALCHART_USE_NAMESPACE
	28
	29	class ChartView : public QChartView
	30	{
	31	public:
	32	ChartView(QWidget *parent = 0);
	33
	34	protected:
	35	void keyPressEvent(QKeyEvent *event);
	36	};
	37
	38	#endif

tests/polarcharttest/main.cpp created 644 +31 0

@@ -0,0 +1,31
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "mainwindow.h"
	22	#include <QApplication>
	23
	24	int main(int argc, char *argv[])
	25	{
	26	QApplication a(argc, argv);
	27	MainWindow w;
	28	w.show();
	29
	30	return a.exec();
	31	}

tests/polarcharttest/mainwindow.cpp created 644 +1136 0

This diff has been collapsed as it changes many lines, (1136 lines changed) Show them Hide them
	@@ -0,0 +1,1136
		1	/****************************************************************************
		2	**
		3	** Copyright (C) 2013 Digia Plc
		4	** All rights reserved.
		5	** For any questions to Digia, please use contact form at http://qt.digia.com
		6	**
		7	** This file is part of the Qt Commercial Charts Add-on.
		8	**
		9	** $QT_BEGIN_LICENSE$
		10	** Licensees holding valid Qt Commercial licenses may use this file in
		11	** accordance with the Qt Commercial License Agreement provided with the
		12	** Software or, alternatively, in accordance with the terms contained in
		13	** a written agreement between you and Digia.
		14	**
		15	** If you have questions regarding the use of this file, please use
		16	** contact form at http://qt.digia.com
		17	** $QT_END_LICENSE$
		18	**
		19	****************************************************************************/
		20
		21	#include "mainwindow.h"
		22	#include "chartview.h"
		23	#include <QScatterSeries>
		24	#include <QLineSeries>
		25	#include <QSplineSeries>
		26	#include <QAreaSeries>
		27	#include <QBarSeries>
		28	#include <QBarSet>
		29	#include <QValueAxis>
		30	#include <QLogValueAxis>
		31	#include <QDateTimeAxis>
		32	#include <QCategoryAxis>
		33	#include <QPolarChart>
		34	#include <QDebug>
		35	#include <qmath.h>
		36	#include <QDateTime>
		37
		38	QTCOMMERCIALCHART_USE_NAMESPACE
		39	#include "ui_mainwindow.h"
		40
		41	MainWindow::MainWindow(QWidget *parent) :
		42	QMainWindow(parent),
		43	ui(new Ui::MainWindow),
		44	m_angularTickCount(9),
		45	m_radialTickCount(11),
		46	m_labelsAngle(0),
		47	m_angularMin(0.0),
		48	m_angularMax(40000.0),
		49	m_radialMin(0.0),
		50	m_radialMax(30000.0),
		51	m_angularShadesVisible(false),
		52	m_radialShadesVisible(false),
		53	m_labelsVisible(true),
		54	m_titleVisible(true),
		55	m_gridVisible(true),
		56	m_arrowVisible(true),
		57	m_angularShadesBrush(new QBrush(Qt::NoBrush)),
		58	m_radialShadesBrush(new QBrush(Qt::NoBrush)),
		59	m_labelBrush(new QBrush(Qt::black)),
		60	m_titleBrush(new QBrush(Qt::black)),
		61	m_angularShadesPen(new QPen(Qt::NoPen)),
		62	m_radialShadesPen(new QPen(Qt::NoPen)),
		63	m_labelPen(new QPen(Qt::NoPen)),
		64	m_titlePen(new QPen(Qt::NoPen)),
		65	m_gridPen(new QPen(QRgb(0x010101))), // Note: Pure black is default color, so it gets overridden by
		66	m_arrowPen(new QPen(QRgb(0x010101))), // default theme if set to that initially. This is an example of workaround.
		67	m_labelFormat(QString("%.2f")),
		68	m_animationOptions(QChart::NoAnimation),
		69	m_angularTitle(QString("Angular Title")),
		70	m_radialTitle(QString("Radial Title")),
		71	m_base(2.0),
		72	m_chart(0),
		73	m_angularAxis(0),
		74	m_radialAxis(0),
		75	m_angularAxisMode(AxisModeNone),
		76	m_radialAxisMode(AxisModeNone),
		77	m_series1(0),
		78	m_series2(0),
		79	m_series3(0),
		80	m_series4(0),
		81	m_series5(0),
		82	m_series6(0),
		83	m_series7(0),
		84	m_dateFormat(QString("mm-ss-zzz")),
		85	m_moreCategories(false)
		86	{
		87	ui->setupUi(this);
		88
		89	ui->angularTicksSpin->setValue(m_angularTickCount);
		90	ui->radialTicksSpin->setValue(m_radialTickCount);
		91	ui->anglesSpin->setValue(m_labelsAngle);
		92	ui->radialMinSpin->setValue(m_radialMin);
		93	ui->radialMaxSpin->setValue(m_radialMax);
		94	ui->angularMinSpin->setValue(m_angularMin);
		95	ui->angularMaxSpin->setValue(m_angularMax);
		96	ui->angularShadesComboBox->setCurrentIndex(0);
		97	ui->radialShadesComboBox->setCurrentIndex(0);
		98	ui->labelFormatEdit->setText(m_labelFormat);
		99	ui->dateFormatEdit->setText(m_dateFormat);
		100	ui->moreCategoriesCheckBox->setChecked(m_moreCategories);
		101
		102	ui->series1checkBox->setChecked(true);
		103	ui->series2checkBox->setChecked(true);
		104	ui->series3checkBox->setChecked(true);
		105	ui->series4checkBox->setChecked(true);
		106	ui->series5checkBox->setChecked(true);
		107	ui->series6checkBox->setChecked(true);
		108	ui->series7checkBox->setChecked(true);
		109
		110	m_currentLabelFont.setFamily(ui->labelFontComboBox->currentFont().family());
		111	m_currentLabelFont.setPixelSize(15);
		112	m_currentTitleFont.setFamily(ui->titleFontComboBox->currentFont().family());
		113	m_currentTitleFont.setPixelSize(30);
		114
		115	ui->labelFontSizeSpin->setValue(m_currentLabelFont.pixelSize());
		116	ui->titleFontSizeSpin->setValue(m_currentTitleFont.pixelSize());
		117
		118	ui->logBaseSpin->setValue(m_base);
		119
		120	initXYValueChart();
		121	setAngularAxis(AxisModeValue);
		122	setRadialAxis(AxisModeValue);
		123
		124	ui->angularAxisComboBox->setCurrentIndex(int(m_angularAxisMode));
		125	ui->radialAxisComboBox->setCurrentIndex(int(m_radialAxisMode));
		126
		127	connect(ui->angularTicksSpin, SIGNAL(valueChanged(int)), this, SLOT(angularTicksChanged(int)));
		128	connect(ui->radialTicksSpin, SIGNAL(valueChanged(int)), this, SLOT(radialTicksChanged(int)));
		129	connect(ui->anglesSpin, SIGNAL(valueChanged(int)), this, SLOT(anglesChanged(int)));
		130	connect(ui->radialMinSpin, SIGNAL(valueChanged(double)), this, SLOT(radialMinChanged(double)));
		131	connect(ui->radialMaxSpin, SIGNAL(valueChanged(double)), this, SLOT(radialMaxChanged(double)));
		132	connect(ui->angularMinSpin, SIGNAL(valueChanged(double)), this, SLOT(angularMinChanged(double)));
		133	connect(ui->angularMaxSpin, SIGNAL(valueChanged(double)), this, SLOT(angularMaxChanged(double)));
		134	connect(ui->angularShadesComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(angularShadesIndexChanged(int)));
		135	connect(ui->radialShadesComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(radialShadesIndexChanged(int)));
		136	connect(ui->animationsComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(animationIndexChanged(int)));
		137	connect(ui->labelFormatEdit, SIGNAL(textEdited(QString)), this, SLOT(labelFormatEdited(QString)));
		138	connect(ui->labelFontComboBox, SIGNAL(currentFontChanged(QFont)), this, SLOT(labelFontChanged(QFont)));
		139	connect(ui->labelFontSizeSpin, SIGNAL(valueChanged(int)), this, SLOT(labelFontSizeChanged(int)));
		140	connect(ui->labelComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(labelsIndexChanged(int)));
		141	connect(ui->titleFontComboBox, SIGNAL(currentFontChanged(QFont)), this, SLOT(titleFontChanged(QFont)));
		142	connect(ui->titleFontSizeSpin, SIGNAL(valueChanged(int)), this, SLOT(titleFontSizeChanged(int)));
		143	connect(ui->titleComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(titleIndexChanged(int)));
		144	connect(ui->gridComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(gridIndexChanged(int)));
		145	connect(ui->arrowComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(arrowIndexChanged(int)));
		146	connect(ui->logBaseSpin, SIGNAL(valueChanged(double)), this, SLOT(logBaseChanged(double)));
		147	connect(ui->angularAxisComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(angularAxisIndexChanged(int)));
		148	connect(ui->radialAxisComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(radialAxisIndexChanged(int)));
		149	connect(ui->niceNumbersCheckBox, SIGNAL(clicked()), this, SLOT(niceNumbersChecked()));
		150	connect(ui->dateFormatEdit, SIGNAL(textEdited(QString)), this, SLOT(dateFormatEdited(QString)));
		151	connect(ui->moreCategoriesCheckBox, SIGNAL(clicked()), this, SLOT(moreCategoriesChecked()));
		152	connect(ui->series1checkBox, SIGNAL(clicked()), this, SLOT(series1CheckBoxChecked()));
		153	connect(ui->series2checkBox, SIGNAL(clicked()), this, SLOT(series2CheckBoxChecked()));
		154	connect(ui->series3checkBox, SIGNAL(clicked()), this, SLOT(series3CheckBoxChecked()));
		155	connect(ui->series4checkBox, SIGNAL(clicked()), this, SLOT(series4CheckBoxChecked()));
		156	connect(ui->series5checkBox, SIGNAL(clicked()), this, SLOT(series5CheckBoxChecked()));
		157	connect(ui->series6checkBox, SIGNAL(clicked()), this, SLOT(series6CheckBoxChecked()));
		158	connect(ui->series7checkBox, SIGNAL(clicked()), this, SLOT(series7CheckBoxChecked()));
		159	connect(ui->themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(themeIndexChanged(int)));
		160
		161	ui->chartView->setChart(m_chart);
		162	ui->chartView->setRenderHint(QPainter::Antialiasing);
		163	}
		164
		165	MainWindow::~MainWindow()
		166	{
		167	delete ui;
		168	delete m_angularShadesBrush;
		169	delete m_radialShadesBrush;
		170	delete m_angularShadesPen;
		171	delete m_radialShadesPen;
		172	}
		173
		174	void MainWindow::initXYValueChart()
		175	{
		176	qreal seriesAngularMin = 1;
		177	qreal seriesAngularMax = 46000;
		178	qreal seriesRadialMin = 1;
		179	qreal seriesRadialMax = 23500;
		180	qreal radialDimension = seriesRadialMax - seriesRadialMin;
		181	qreal angularDimension = seriesAngularMax - seriesAngularMin;
		182
		183	// Scatter series, points outside min-max ranges should not be drawn
		184	m_series1 = new QScatterSeries();
		185	m_series1->setName("scatter");
		186	qreal scatterCount = 10;
		187	qreal scatterAngularStep = angularDimension / scatterCount;
		188	qreal scatterRadialStep = radialDimension / scatterCount;
		189	for (qreal i = 0.0; i < scatterCount; i++) {
		190	m_series1->append((i * scatterAngularStep) + seriesAngularMin, (i * scatterRadialStep) + seriesRadialMin);
		191	//qDebug() << m_series1->points().last();
		192	}
		193	m_series1->setMarkerSize(10);
		194	*m_series1 << QPointF(50, 50) << QPointF(150, 150) << QPointF(250, 250) << QPointF(350, 350) << QPointF(450, 450);
		195	*m_series1 << QPointF(1050, 0.50) << QPointF(1150, 0.25) << QPointF(1250, 0.12) << QPointF(1350, 0.075) << QPointF(1450, 0.036);
		196	*m_series1 << QPointF(0.50, 2000) << QPointF(0.25, 3500) << QPointF(0.12, 5000) << QPointF(0.075, 6500) << QPointF(0.036, 8000);
		197
		198	// Line series, points outside min-max ranges should not be drawn,
		199	// but lines should be properly interpolated at chart edges
		200	m_series2 = new QLineSeries();
		201	m_series2->setName("line 1");
		202	qreal lineCount = 100;
		203	qreal lineAngularStep = angularDimension / lineCount;
		204	qreal lineRadialStep = radialDimension / lineCount;
		205	for (qreal i = 0.0; i < lineCount; i++) {
		206	m_series2->append((i * lineAngularStep) + seriesAngularMin, (i * lineRadialStep) + seriesRadialMin);
		207	//qDebug() << m_series2->points().last();
		208	}
		209	QPen series2Pen = QPen(Qt::blue, 10);
		210	//series2Pen.setStyle(Qt::DashDotDotLine);
		211	m_series2->setPen(series2Pen);
		212
		213	m_series3 = new QLineSeries();
		214	m_series3->setName("Area upper");
		215	lineCount = 87;
		216	lineAngularStep = angularDimension / lineCount;
		217	lineRadialStep = radialDimension / lineCount;
		218	for (qreal i = 1.0; i <= lineCount; i++) {
		219	m_series3->append((i * lineAngularStep) + seriesAngularMin, (i * lineRadialStep) + seriesRadialMin + 200.0);
		220	//qDebug() << m_series3->points().last();
		221	}
		222
		223	m_series4 = new QLineSeries();
		224	m_series4->setName("Area lower");
		225	lineCount = 89;
		226	lineAngularStep = angularDimension / lineCount;
		227	lineRadialStep = radialDimension / lineCount;
		228	for (qreal i = 1.0; i <= lineCount; i++) {
		229	m_series4->append((i * lineAngularStep) + seriesAngularMin + 100.0, (i * lineRadialStep) + seriesRadialMin + i * 300.0);
		230	//qDebug() << m_series4->points().last();
		231	}
		232
		233	m_series5 = new QAreaSeries();
		234	m_series5->setName("area");
		235	m_series5->setUpperSeries(m_series3);
		236	m_series5->setLowerSeries(m_series4);
		237	m_series5->setOpacity(0.5);
		238
		239	m_series6 = new QSplineSeries();
		240	m_series6->setName("spline");
		241	qreal ad = angularDimension / 20;
		242	qreal rd = radialDimension / 10;
		243	m_series6->append(seriesAngularMin, seriesRadialMin + rd * 2);
		244	m_series6->append(seriesAngularMin + ad, seriesRadialMin + rd * 5);
		245	m_series6->append(seriesAngularMin + ad * 2, seriesRadialMin + rd * 4);
		246	m_series6->append(seriesAngularMin + ad * 3, seriesRadialMin + rd * 9);
		247	m_series6->append(seriesAngularMin + ad * 4, seriesRadialMin + rd * 11);
		248	m_series6->append(seriesAngularMin + ad * 5, seriesRadialMin + rd * 12);
		249	m_series6->append(seriesAngularMin + ad * 6, seriesRadialMin + rd * 9);
		250	m_series6->append(seriesAngularMin + ad * 7, seriesRadialMin + rd * 11);
		251	m_series6->append(seriesAngularMin + ad * 8, seriesRadialMin + rd * 12);
		252	m_series6->append(seriesAngularMin + ad * 9, seriesRadialMin + rd * 6);
		253	m_series6->append(seriesAngularMin + ad * 10, seriesRadialMin + rd * 4);
		254	m_series6->append(seriesAngularMin + ad * 10, seriesRadialMin + rd * 8);
		255	m_series6->append(seriesAngularMin + ad * 11, seriesRadialMin + rd * 9);
		256	m_series6->append(seriesAngularMin + ad * 12, seriesRadialMin + rd * 11);
		257	m_series6->append(seriesAngularMin + ad * 13, seriesRadialMin + rd * 12);
		258	m_series6->append(seriesAngularMin + ad * 14, seriesRadialMin + rd * 6);
		259	m_series6->append(seriesAngularMin + ad * 15, seriesRadialMin + rd * 3);
		260	m_series6->append(seriesAngularMin + ad * 16, seriesRadialMin + rd * 2);
		261	m_series6->append(seriesAngularMin + ad * 17, seriesRadialMin + rd * 6);
		262	m_series6->append(seriesAngularMin + ad * 18, seriesRadialMin + rd * 6);
		263	m_series6->append(seriesAngularMin + ad * 19, seriesRadialMin + rd * 6);
		264	m_series6->append(seriesAngularMin + ad * 20, seriesRadialMin + rd * 6);
		265	m_series6->append(seriesAngularMin + ad * 19, seriesRadialMin + rd * 2);
		266	m_series6->append(seriesAngularMin + ad * 18, seriesRadialMin + rd * 9);
		267	m_series6->append(seriesAngularMin + ad * 17, seriesRadialMin + rd * 7);
		268	m_series6->append(seriesAngularMin + ad * 16, seriesRadialMin + rd * 3);
		269	m_series6->append(seriesAngularMin + ad * 15, seriesRadialMin + rd * 1);
		270	m_series6->append(seriesAngularMin + ad * 14, seriesRadialMin + rd * 7);
		271	m_series6->append(seriesAngularMin + ad * 13, seriesRadialMin + rd * 5);
		272	m_series6->append(seriesAngularMin + ad * 12, seriesRadialMin + rd * 9);
		273	m_series6->append(seriesAngularMin + ad * 11, seriesRadialMin + rd * 1);
		274	m_series6->append(seriesAngularMin + ad * 10, seriesRadialMin + rd * 4);
		275	m_series6->append(seriesAngularMin + ad * 9, seriesRadialMin + rd * 1);
		276	m_series6->append(seriesAngularMin + ad * 8, seriesRadialMin + rd * 2);
		277	m_series6->append(seriesAngularMin + ad * 7, seriesRadialMin + rd * 4);
		278	m_series6->append(seriesAngularMin + ad * 6, seriesRadialMin + rd * 8);
		279	m_series6->append(seriesAngularMin + ad * 5, seriesRadialMin + rd * 12);
		280	m_series6->append(seriesAngularMin + ad * 4, seriesRadialMin + rd * 9);
		281	m_series6->append(seriesAngularMin + ad * 3, seriesRadialMin + rd * 8);
		282	m_series6->append(seriesAngularMin + ad * 2, seriesRadialMin + rd * 7);
		283	m_series6->append(seriesAngularMin + ad, seriesRadialMin + rd * 4);
		284	m_series6->append(seriesAngularMin, seriesRadialMin + rd * 10);
		285
		286	m_series6->setPointsVisible(true);
		287	QPen series6Pen = QPen(Qt::red, 10);
		288	//series6Pen.setStyle(Qt::DashDotDotLine);
		289	m_series6->setPen(series6Pen);
		290
		291	// m_series7 shows points at category intersections
		292	m_series7 = new QScatterSeries();
		293	m_series7->setName("Category check");
		294	m_series7->setMarkerSize(7);
		295	m_series7->setBrush(QColor(Qt::red));
		296	m_series7->setMarkerShape(QScatterSeries::MarkerShapeRectangle);
		297	*m_series7 << QPointF(1000, 1000)
		298	<< QPointF(1000, 2000)
		299	<< QPointF(1000, 4000)
		300	<< QPointF(1000, 9000)
		301	<< QPointF(1000, 14000)
		302	<< QPointF(1000, 16500)
		303	<< QPointF(1000, 19000)
		304
		305	<< QPointF(4000, 1000)
		306	<< QPointF(4000, 2000)
		307	<< QPointF(4000, 4000)
		308	<< QPointF(4000, 9000)
		309	<< QPointF(4000, 14000)
		310	<< QPointF(4000, 16500)
		311	<< QPointF(4000, 19000)
		312
		313	<< QPointF(7000, 1000)
		314	<< QPointF(7000, 2000)
		315	<< QPointF(7000, 4000)
		316	<< QPointF(7000, 9000)
		317	<< QPointF(7000, 14000)
		318	<< QPointF(7000, 16500)
		319	<< QPointF(7000, 19000)
		320
		321	<< QPointF(12000, 1000)
		322	<< QPointF(12000, 2000)
		323	<< QPointF(12000, 4000)
		324	<< QPointF(12000, 9000)
		325	<< QPointF(12000, 14000)
		326	<< QPointF(12000, 16500)
		327	<< QPointF(12000, 19000)
		328
		329	<< QPointF(17000, 1000)
		330	<< QPointF(17000, 2000)
		331	<< QPointF(17000, 4000)
		332	<< QPointF(17000, 9000)
		333	<< QPointF(17000, 14000)
		334	<< QPointF(17000, 16500)
		335	<< QPointF(17000, 19000)
		336
		337	<< QPointF(22000, 1000)
		338	<< QPointF(22000, 2000)
		339	<< QPointF(22000, 4000)
		340	<< QPointF(22000, 9000)
		341	<< QPointF(22000, 14000)
		342	<< QPointF(22000, 16500)
		343	<< QPointF(22000, 19000)
		344
		345	<< QPointF(28000, 1000)
		346	<< QPointF(28000, 2000)
		347	<< QPointF(28000, 4000)
		348	<< QPointF(28000, 9000)
		349	<< QPointF(28000, 14000)
		350	<< QPointF(28000, 16500)
		351	<< QPointF(28000, 19000);
		352
		353	m_chart = new QPolarChart();
		354
		355	m_chart->addSeries(m_series1);
		356	m_chart->addSeries(m_series2);
		357	m_chart->addSeries(m_series3);
		358	m_chart->addSeries(m_series4);
		359	m_chart->addSeries(m_series5);
		360	m_chart->addSeries(m_series6);
		361	m_chart->addSeries(m_series7);
		362
		363	connect(m_series1, SIGNAL(clicked(QPointF)), this, SLOT(seriesClicked(QPointF)));
		364	connect(m_series2, SIGNAL(clicked(QPointF)), this, SLOT(seriesClicked(QPointF)));
		365	connect(m_series3, SIGNAL(clicked(QPointF)), this, SLOT(seriesClicked(QPointF)));
		366	connect(m_series4, SIGNAL(clicked(QPointF)), this, SLOT(seriesClicked(QPointF)));
		367	connect(m_series5, SIGNAL(clicked(QPointF)), this, SLOT(seriesClicked(QPointF)));
		368	connect(m_series6, SIGNAL(clicked(QPointF)), this, SLOT(seriesClicked(QPointF)));
		369	connect(m_series7, SIGNAL(clicked(QPointF)), this, SLOT(seriesClicked(QPointF)));
		370	connect(m_series1, SIGNAL(hovered(QPointF, bool)), this, SLOT(seriesHovered(QPointF, bool)));
		371	connect(m_series2, SIGNAL(hovered(QPointF, bool)), this, SLOT(seriesHovered(QPointF, bool)));
		372	connect(m_series3, SIGNAL(hovered(QPointF, bool)), this, SLOT(seriesHovered(QPointF, bool)));
		373	connect(m_series4, SIGNAL(hovered(QPointF, bool)), this, SLOT(seriesHovered(QPointF, bool)));
		374	connect(m_series5, SIGNAL(hovered(QPointF, bool)), this, SLOT(seriesHovered(QPointF, bool)));
		375	connect(m_series6, SIGNAL(hovered(QPointF, bool)), this, SLOT(seriesHovered(QPointF, bool)));
		376	connect(m_series7, SIGNAL(hovered(QPointF, bool)), this, SLOT(seriesHovered(QPointF, bool)));
		377
		378	m_chart->setTitle("Use arrow keys to scroll and +/- to zoom");
		379	m_chart->setAnimationOptions(m_animationOptions);
		380	//m_chart->legend()->setVisible(false);
		381	m_chart->setAcceptHoverEvents(true);
		382	}
		383
		384	void MainWindow::setAngularAxis(MainWindow::AxisMode mode)
		385	{
		386	if (m_angularAxis) {
		387	m_chart->removeAxis(m_angularAxis);
		388	delete m_angularAxis;
		389	m_angularAxis = 0;
		390	}
		391
		392	m_angularAxisMode = mode;
		393
		394	switch (m_angularAxisMode) {
		395	case AxisModeNone:
		396	return;
		397	case AxisModeValue:
		398	m_angularAxis = new QValueAxis();
		399	static_cast<QValueAxis *>(m_angularAxis)->setTickCount(m_angularTickCount);
		400	static_cast<QValueAxis *>(m_angularAxis)->setLabelFormat(m_labelFormat);
		401	break;
		402	case AxisModeLogValue:
		403	m_angularAxis = new QLogValueAxis();
		404	static_cast<QLogValueAxis *>(m_angularAxis)->setBase(m_base);
		405	static_cast<QLogValueAxis *>(m_angularAxis)->setLabelFormat(m_labelFormat);
		406	break;
		407	case AxisModeDateTime:
		408	m_angularAxis = new QDateTimeAxis();
		409	static_cast<QDateTimeAxis *>(m_angularAxis)->setTickCount(m_angularTickCount);
		410	static_cast<QDateTimeAxis *>(m_angularAxis)->setFormat(m_dateFormat);
		411	break;
		412	case AxisModeCategory:
		413	m_angularAxis = new QCategoryAxis();
		414	applyCategories();
		415	break;
		416	default:
		417	qWarning() << "Unsupported AxisMode";
		418	break;
		419	}
		420
		421	m_angularAxis->setLabelsAngle(m_labelsAngle);
		422	m_angularAxis->setLabelsFont(m_currentLabelFont);
		423	m_angularAxis->setLabelsBrush(*m_labelBrush);
		424	m_angularAxis->setLabelsPen(*m_labelPen);
		425	m_angularAxis->setLabelsVisible(m_labelsVisible);
		426	m_angularAxis->setShadesBrush(*m_angularShadesBrush);
		427	m_angularAxis->setShadesPen(*m_angularShadesPen);
		428	m_angularAxis->setShadesVisible(m_angularShadesVisible);
		429	m_angularAxis->setTitleFont(m_currentTitleFont);
		430	m_angularAxis->setTitleBrush(*m_titleBrush);
		431	m_angularAxis->setTitlePen(*m_titlePen);
		432	m_angularAxis->setTitleVisible(m_titleVisible);
		433	m_angularAxis->setTitleText(m_angularTitle);
		434	m_angularAxis->setGridLinePen(*m_gridPen);
		435	m_angularAxis->setGridLineVisible(m_gridVisible);
		436	m_angularAxis->setLinePen(*m_arrowPen);
		437	m_angularAxis->setLineVisible(m_arrowVisible);
		438
		439	m_chart->addAxis(m_angularAxis, QPolarChart::PolarOrientationAngular);
		440
		441	m_series1->attachAxis(m_angularAxis);
		442	m_series2->attachAxis(m_angularAxis);
		443	m_series3->attachAxis(m_angularAxis);
		444	m_series4->attachAxis(m_angularAxis);
		445	m_series5->attachAxis(m_angularAxis);
		446	m_series6->attachAxis(m_angularAxis);
		447	m_series7->attachAxis(m_angularAxis);
		448
		449	applyRanges();
		450
		451	//connect(m_angularAxis, SIGNAL(rangeChanged(qreal, qreal)), this, SLOT(angularRangeChanged(qreal, qreal)));
		452	}
		453
		454	void MainWindow::setRadialAxis(MainWindow::AxisMode mode)
		455	{
		456	if (m_radialAxis) {
		457	m_chart->removeAxis(m_radialAxis);
		458	delete m_radialAxis;
		459	m_radialAxis = 0;
		460	}
		461
		462	m_radialAxisMode = mode;
		463
		464	switch (m_radialAxisMode) {
		465	case AxisModeNone:
		466	return;
		467	case AxisModeValue:
		468	m_radialAxis = new QValueAxis();
		469	static_cast<QValueAxis *>(m_radialAxis)->setTickCount(m_radialTickCount);
		470	static_cast<QValueAxis *>(m_radialAxis)->setLabelFormat(m_labelFormat);
		471	break;
		472	case AxisModeLogValue:
		473	m_radialAxis = new QLogValueAxis();
		474	static_cast<QLogValueAxis *>(m_radialAxis)->setBase(m_base);
		475	static_cast<QLogValueAxis *>(m_radialAxis)->setLabelFormat(m_labelFormat);
		476	break;
		477	case AxisModeDateTime:
		478	m_radialAxis = new QDateTimeAxis();
		479	static_cast<QDateTimeAxis *>(m_radialAxis)->setTickCount(m_radialTickCount);
		480	static_cast<QDateTimeAxis *>(m_radialAxis)->setFormat(m_dateFormat);
		481	break;
		482	case AxisModeCategory:
		483	m_radialAxis = new QCategoryAxis();
		484	applyCategories();
		485	break;
		486	default:
		487	qWarning() << "Unsupported AxisMode";
		488	break;
		489	}
		490
		491	m_radialAxis->setLabelsAngle(m_labelsAngle);
		492	m_radialAxis->setLabelsFont(m_currentLabelFont);
		493	m_radialAxis->setLabelsBrush(*m_labelBrush);
		494	m_radialAxis->setLabelsPen(*m_labelPen);
		495	m_radialAxis->setLabelsVisible(m_labelsVisible);
		496	m_radialAxis->setShadesBrush(*m_radialShadesBrush);
		497	m_radialAxis->setShadesPen(*m_radialShadesPen);
		498	m_radialAxis->setShadesVisible(m_radialShadesVisible);
		499	m_radialAxis->setTitleFont(m_currentTitleFont);
		500	m_radialAxis->setTitleBrush(*m_titleBrush);
		501	m_radialAxis->setTitlePen(*m_titlePen);
		502	m_radialAxis->setTitleVisible(m_titleVisible);
		503	m_radialAxis->setTitleText(m_radialTitle);
		504	m_radialAxis->setGridLinePen(*m_gridPen);
		505	m_radialAxis->setGridLineVisible(m_gridVisible);
		506	m_radialAxis->setLinePen(*m_arrowPen);
		507	m_radialAxis->setLineVisible(m_arrowVisible);
		508
		509	m_chart->addAxis(m_radialAxis, QPolarChart::PolarOrientationRadial);
		510
		511	m_series1->attachAxis(m_radialAxis);
		512	m_series2->attachAxis(m_radialAxis);
		513	m_series3->attachAxis(m_radialAxis);
		514	m_series4->attachAxis(m_radialAxis);
		515	m_series5->attachAxis(m_radialAxis);
		516	m_series6->attachAxis(m_radialAxis);
		517	m_series7->attachAxis(m_radialAxis);
		518
		519	applyRanges();
		520
		521	series1CheckBoxChecked();
		522	series2CheckBoxChecked();
		523	series3CheckBoxChecked();
		524	series4CheckBoxChecked();
		525	series5CheckBoxChecked();
		526	series6CheckBoxChecked();
		527	series7CheckBoxChecked();
		528
		529	//connect(m_radialAxis, SIGNAL(rangeChanged(qreal, qreal)), this, SLOT(radialRangeChanged(qreal, qreal)));
		530	}
		531
		532	void MainWindow::applyRanges()
		533	{
		534	if (ui->niceNumbersCheckBox->isChecked()) {
		535	if (m_angularAxisMode == AxisModeValue) {
		536	static_cast<QValueAxis *>(m_angularAxis)->applyNiceNumbers();
		537	m_angularMin = static_cast<QValueAxis *>(m_angularAxis)->min();
		538	m_angularMax = static_cast<QValueAxis *>(m_angularAxis)->max();
		539	m_angularTickCount = static_cast<QValueAxis *>(m_angularAxis)->tickCount();
		540	}
		541	if (m_radialAxisMode == AxisModeValue) {
		542	static_cast<QValueAxis *>(m_radialAxis)->applyNiceNumbers();
		543	m_radialMin = static_cast<QValueAxis *>(m_radialAxis)->min();
		544	m_radialMax = static_cast<QValueAxis *>(m_radialAxis)->max();
		545	m_radialTickCount = static_cast<QValueAxis *>(m_radialAxis)->tickCount();
		546	}
		547	}
		548
		549	if (m_angularAxis)
		550	m_angularAxis->setRange(m_angularMin, m_angularMax);
		551	if (m_radialAxis)
		552	m_radialAxis->setRange(m_radialMin, m_radialMax);
		553	}
		554
		555	void MainWindow::angularTicksChanged(int value)
		556	{
		557	m_angularTickCount = value;
		558	if (m_angularAxisMode == AxisModeValue)
		559	static_cast<QValueAxis *>(m_angularAxis)->setTickCount(m_angularTickCount);
		560	else if (m_angularAxisMode == AxisModeDateTime)
		561	static_cast<QDateTimeAxis *>(m_angularAxis)->setTickCount(m_angularTickCount);
		562	}
		563
		564	void MainWindow::radialTicksChanged(int value)
		565	{
		566	m_radialTickCount = value;
		567	if (m_radialAxisMode == AxisModeValue)
		568	static_cast<QValueAxis *>(m_radialAxis)->setTickCount(m_radialTickCount);
		569	else if (m_radialAxisMode == AxisModeDateTime)
		570	static_cast<QDateTimeAxis *>(m_radialAxis)->setTickCount(m_radialTickCount);
		571	}
		572
		573	void MainWindow::anglesChanged(int value)
		574	{
		575	m_labelsAngle = value;
		576	m_radialAxis->setLabelsAngle(m_labelsAngle);
		577	m_angularAxis->setLabelsAngle(m_labelsAngle);
		578	}
		579
		580	void MainWindow::angularMinChanged(double value)
		581	{
		582	m_angularMin = value;
		583	if (m_angularAxisMode != AxisModeDateTime) {
		584	m_angularAxis->setMin(m_angularMin);
		585	} else {
		586	QDateTime dateTime;
		587	dateTime.setMSecsSinceEpoch(qint64(m_angularMin));
		588	m_angularAxis->setMin(dateTime);
		589	}
		590	}
		591
		592	void MainWindow::angularMaxChanged(double value)
		593	{
		594	m_angularMax = value;
		595	if (m_angularAxisMode != AxisModeDateTime) {
		596	m_angularAxis->setMax(m_angularMax);
		597	} else {
		598	QDateTime dateTime;
		599	dateTime.setMSecsSinceEpoch(qint64(m_angularMax));
		600	m_angularAxis->setMax(dateTime);
		601	}
		602	}
		603
		604	void MainWindow::radialMinChanged(double value)
		605	{
		606	m_radialMin = value;
		607	if (m_radialAxisMode != AxisModeDateTime) {
		608	m_radialAxis->setMin(m_radialMin);
		609	} else {
		610	QDateTime dateTime;
		611	dateTime.setMSecsSinceEpoch(qint64(m_radialMin));
		612	m_radialAxis->setMin(dateTime);
		613	}
		614	}
		615
		616	void MainWindow::radialMaxChanged(double value)
		617	{
		618	m_radialMax = value;
		619	if (m_radialAxisMode != AxisModeDateTime) {
		620	m_radialAxis->setMax(m_radialMax);
		621	} else {
		622	QDateTime dateTime;
		623	dateTime.setMSecsSinceEpoch(qint64(m_radialMax));
		624	m_radialAxis->setMax(dateTime);
		625	}
		626	}
		627
		628	void MainWindow::angularShadesIndexChanged(int index)
		629	{
		630	delete m_angularShadesBrush;
		631	delete m_angularShadesPen;
		632
		633	switch (index) {
		634	case 0:
		635	m_angularShadesBrush = new QBrush(Qt::NoBrush);
		636	m_angularShadesPen = new QPen(Qt::NoPen);
		637	m_angularShadesVisible = false;
		638	break;
		639	case 1:
		640	m_angularShadesBrush = new QBrush(Qt::lightGray);
		641	m_angularShadesPen = new QPen(Qt::NoPen);
		642	m_angularShadesVisible = true;
		643	break;
		644	case 2:
		645	m_angularShadesBrush = new QBrush(Qt::yellow);
		646	m_angularShadesPen = new QPen(Qt::DotLine);
		647	m_angularShadesPen->setWidth(2);
		648	m_angularShadesVisible = true;
		649	break;
		650	default:
		651	break;
		652	}
		653
		654	m_angularAxis->setShadesBrush(*m_angularShadesBrush);
		655	m_angularAxis->setShadesPen(*m_angularShadesPen);
		656	m_angularAxis->setShadesVisible(m_angularShadesVisible);
		657	}
		658
		659	void MainWindow::radialShadesIndexChanged(int index)
		660	{
		661	delete m_radialShadesBrush;
		662	delete m_radialShadesPen;
		663
		664	switch (index) {
		665	case 0:
		666	m_radialShadesBrush = new QBrush(Qt::NoBrush);
		667	m_radialShadesPen = new QPen(Qt::NoPen);
		668	m_radialShadesVisible = false;
		669	break;
		670	case 1:
		671	m_radialShadesBrush = new QBrush(Qt::green);
		672	m_radialShadesPen = new QPen(Qt::NoPen);
		673	m_radialShadesVisible = true;
		674	break;
		675	case 2:
		676	m_radialShadesBrush = new QBrush(Qt::blue);
		677	m_radialShadesPen = new QPen(Qt::DotLine);
		678	m_radialShadesPen->setWidth(2);
		679	m_radialShadesVisible = true;
		680	break;
		681	default:
		682	break;
		683	}
		684
		685	m_radialAxis->setShadesBrush(*m_radialShadesBrush);
		686	m_radialAxis->setShadesPen(*m_radialShadesPen);
		687	m_radialAxis->setShadesVisible(m_radialShadesVisible);
		688	}
		689
		690	void MainWindow::labelFormatEdited(const QString &text)
		691	{
		692	m_labelFormat = text;
		693	if (m_angularAxisMode == AxisModeValue)
		694	static_cast<QValueAxis *>(m_angularAxis)->setLabelFormat(m_labelFormat);
		695	else if (m_angularAxisMode == AxisModeLogValue)
		696	static_cast<QLogValueAxis *>(m_angularAxis)->setLabelFormat(m_labelFormat);
		697
		698	if (m_radialAxisMode == AxisModeValue)
		699	static_cast<QValueAxis *>(m_radialAxis)->setLabelFormat(m_labelFormat);
		700	else if (m_radialAxisMode == AxisModeLogValue)
		701	static_cast<QLogValueAxis *>(m_radialAxis)->setLabelFormat(m_labelFormat);
		702	}
		703
		704	void MainWindow::labelFontChanged(const QFont &font)
		705	{
		706	m_currentLabelFont = font;
		707	m_currentLabelFont.setPixelSize(ui->labelFontSizeSpin->value());
		708	m_angularAxis->setLabelsFont(m_currentLabelFont);
		709	m_radialAxis->setLabelsFont(m_currentLabelFont);
		710	}
		711
		712	void MainWindow::labelFontSizeChanged(int value)
		713	{
		714	m_currentLabelFont = ui->labelFontComboBox->currentFont();
		715	m_currentLabelFont.setPixelSize(value);
		716	m_angularAxis->setLabelsFont(m_currentLabelFont);
		717	m_radialAxis->setLabelsFont(m_currentLabelFont);
		718	}
		719
		720	void MainWindow::animationIndexChanged(int index)
		721	{
		722	switch (index) {
		723	case 0:
		724	m_animationOptions = QChart::NoAnimation;
		725	break;
		726	case 1:
		727	m_animationOptions = QChart::SeriesAnimations;
		728	break;
		729	case 2:
		730	m_animationOptions = QChart::GridAxisAnimations;
		731	break;
		732	case 3:
		733	m_animationOptions = QChart::AllAnimations;
		734	break;
		735	default:
		736	break;
		737	}
		738
		739	m_chart->setAnimationOptions(m_animationOptions);
		740	}
		741
		742	void MainWindow::labelsIndexChanged(int index)
		743	{
		744	delete m_labelBrush;
		745	delete m_labelPen;
		746
		747	switch (index) {
		748	case 0:
		749	m_labelBrush = new QBrush(Qt::NoBrush);
		750	m_labelPen = new QPen(Qt::NoPen);
		751	m_labelsVisible = false;
		752	break;
		753	case 1:
		754	m_labelBrush = new QBrush(Qt::black);
		755	m_labelPen = new QPen(Qt::NoPen);
		756	m_labelsVisible = true;
		757	break;
		758	case 2:
		759	m_labelBrush = new QBrush(Qt::white);
		760	m_labelPen = new QPen(Qt::blue);
		761	m_labelsVisible = true;
		762	break;
		763	default:
		764	break;
		765	}
		766
		767	m_radialAxis->setLabelsBrush(*m_labelBrush);
		768	m_radialAxis->setLabelsPen(*m_labelPen);
		769	m_radialAxis->setLabelsVisible(m_labelsVisible);
		770	m_angularAxis->setLabelsBrush(*m_labelBrush);
		771	m_angularAxis->setLabelsPen(*m_labelPen);
		772	m_angularAxis->setLabelsVisible(m_labelsVisible);
		773	}
		774
		775	void MainWindow::titleIndexChanged(int index)
		776	{
		777	delete m_titleBrush;
		778	delete m_titlePen;
		779
		780	switch (index) {
		781	case 0:
		782	m_titleBrush = new QBrush(Qt::NoBrush);
		783	m_titlePen = new QPen(Qt::NoPen);
		784	m_titleVisible = false;
		785	m_angularTitle = QString();
		786	m_radialTitle = QString();
		787	break;
		788	case 1:
		789	m_titleBrush = new QBrush(Qt::NoBrush);
		790	m_titlePen = new QPen(Qt::NoPen);
		791	m_titleVisible = true;
		792	m_angularTitle = QString();
		793	m_radialTitle = QString();
		794	break;
		795	case 2:
		796	m_titleBrush = new QBrush(Qt::NoBrush);
		797	m_titlePen = new QPen(Qt::NoPen);
		798	m_titleVisible = false;
		799	m_angularTitle = QString("Invisible Ang. Title!");
		800	m_radialTitle = QString("Invisible Rad. Title!");
		801	break;
		802	case 3:
		803	m_titleBrush = new QBrush(Qt::black);
		804	m_titlePen = new QPen(Qt::NoPen);
		805	m_titleVisible = true;
		806	m_angularTitle = QString("Angular Title");
		807	m_radialTitle = QString("Radial Title");
		808	break;
		809	case 4:
		810	m_titleBrush = new QBrush(Qt::white);
		811	m_titlePen = new QPen(Qt::blue);
		812	m_titleVisible = true;
		813	m_angularTitle = QString("Angular Blue Title");
		814	m_radialTitle = QString("Radial Blue Title");
		815	break;
		816	default:
		817	break;
		818	}
		819
		820	m_radialAxis->setTitleBrush(*m_titleBrush);
		821	m_radialAxis->setTitlePen(*m_titlePen);
		822	m_radialAxis->setTitleVisible(m_titleVisible);
		823	m_radialAxis->setTitleText(m_radialTitle);
		824	m_angularAxis->setTitleBrush(*m_titleBrush);
		825	m_angularAxis->setTitlePen(*m_titlePen);
		826	m_angularAxis->setTitleVisible(m_titleVisible);
		827	m_angularAxis->setTitleText(m_angularTitle);
		828	}
		829
		830	void MainWindow::titleFontChanged(const QFont &font)
		831	{
		832	m_currentTitleFont = font;
		833	m_currentTitleFont.setPixelSize(ui->titleFontSizeSpin->value());
		834	m_angularAxis->setTitleFont(m_currentTitleFont);
		835	m_radialAxis->setTitleFont(m_currentTitleFont);
		836	}
		837
		838	void MainWindow::titleFontSizeChanged(int value)
		839	{
		840	m_currentTitleFont = ui->titleFontComboBox->currentFont();
		841	m_currentTitleFont.setPixelSize(value);
		842	m_angularAxis->setTitleFont(m_currentTitleFont);
		843	m_radialAxis->setTitleFont(m_currentTitleFont);
		844	}
		845
		846	void MainWindow::gridIndexChanged(int index)
		847	{
		848	delete m_gridPen;
		849
		850	switch (index) {
		851	case 0:
		852	m_gridPen = new QPen(Qt::NoPen);
		853	m_gridVisible = false;
		854	break;
		855	case 1:
		856	m_gridPen = new QPen(Qt::black);
		857	m_gridVisible = true;
		858	break;
		859	case 2:
		860	m_gridPen = new QPen(Qt::red);
		861	m_gridPen->setStyle(Qt::DashDotLine);
		862	m_gridPen->setWidth(3);
		863	m_gridVisible = true;
		864	break;
		865	default:
		866	break;
		867	}
		868
		869	m_angularAxis->setGridLinePen(*m_gridPen);
		870	m_angularAxis->setGridLineVisible(m_gridVisible);
		871	m_radialAxis->setGridLinePen(*m_gridPen);
		872	m_radialAxis->setGridLineVisible(m_gridVisible);
		873	}
		874
		875	void MainWindow::arrowIndexChanged(int index)
		876	{
		877	delete m_arrowPen;
		878
		879	switch (index) {
		880	case 0:
		881	m_arrowPen = new QPen(Qt::NoPen);
		882	m_arrowVisible = false;
		883	break;
		884	case 1:
		885	m_arrowPen = new QPen(Qt::black);
		886	m_arrowVisible = true;
		887	break;
		888	case 2:
		889	m_arrowPen = new QPen(Qt::red);
		890	m_arrowPen->setStyle(Qt::DashDotLine);
		891	m_arrowPen->setWidth(3);
		892	m_arrowVisible = true;
		893	break;
		894	default:
		895	break;
		896	}
		897
		898	m_angularAxis->setLinePen(*m_arrowPen);
		899	m_angularAxis->setLineVisible(m_arrowVisible);
		900	m_radialAxis->setLinePen(*m_arrowPen);
		901	m_radialAxis->setLineVisible(m_arrowVisible);
		902	}
		903
		904	void MainWindow::angularRangeChanged(qreal min, qreal max)
		905	{
		906	if (!qFuzzyCompare(ui->angularMinSpin->value(), min))
		907	ui->angularMinSpin->setValue(min);
		908	if (!qFuzzyCompare(ui->angularMaxSpin->value(), max))
		909	ui->angularMaxSpin->setValue(max);
		910	}
		911
		912	void MainWindow::radialRangeChanged(qreal min, qreal max)
		913	{
		914	if (!qFuzzyCompare(ui->radialMinSpin->value(), min))
		915	ui->radialMinSpin->setValue(min);
		916	if (!qFuzzyCompare(ui->radialMaxSpin->value(), max))
		917	ui->radialMaxSpin->setValue(max);
		918	}
		919
		920	void MainWindow::angularAxisIndexChanged(int index)
		921	{
		922	switch (index) {
		923	case 0:
		924	setAngularAxis(AxisModeNone);
		925	break;
		926	case 1:
		927	setAngularAxis(AxisModeValue);
		928	break;
		929	case 2:
		930	setAngularAxis(AxisModeLogValue);
		931	break;
		932	case 3:
		933	setAngularAxis(AxisModeDateTime);
		934	break;
		935	case 4:
		936	setAngularAxis(AxisModeCategory);
		937	break;
		938	default:
		939	qWarning("Invalid Index!");
		940	}
		941	}
		942
		943	void MainWindow::radialAxisIndexChanged(int index)
		944	{
		945	switch (index) {
		946	case 0:
		947	setRadialAxis(AxisModeNone);
		948	break;
		949	case 1:
		950	setRadialAxis(AxisModeValue);
		951	break;
		952	case 2:
		953	setRadialAxis(AxisModeLogValue);
		954	break;
		955	case 3:
		956	setRadialAxis(AxisModeDateTime);
		957	break;
		958	case 4:
		959	setRadialAxis(AxisModeCategory);
		960	break;
		961	default:
		962	qWarning("Invalid Index!");
		963	}
		964	}
		965
		966	void MainWindow::logBaseChanged(double value)
		967	{
		968	m_base = value;
		969	if (m_angularAxisMode == AxisModeLogValue)
		970	static_cast<QLogValueAxis *>(m_angularAxis)->setBase(m_base);
		971	if (m_radialAxisMode == AxisModeLogValue)
		972	static_cast<QLogValueAxis *>(m_radialAxis)->setBase(m_base);
		973	}
		974
		975	void MainWindow::niceNumbersChecked()
		976	{
		977	if (ui->niceNumbersCheckBox->isChecked())
		978	applyRanges();
		979	}
		980
		981	void MainWindow::dateFormatEdited(const QString &text)
		982	{
		983	m_dateFormat = text;
		984	if (m_angularAxisMode == AxisModeDateTime)
		985	static_cast<QDateTimeAxis *>(m_angularAxis)->setFormat(m_dateFormat);
		986	if (m_radialAxisMode == AxisModeDateTime)
		987	static_cast<QDateTimeAxis *>(m_radialAxis)->setFormat(m_dateFormat);
		988	}
		989
		990	void MainWindow::moreCategoriesChecked()
		991	{
		992	applyCategories();
		993	m_moreCategories = ui->moreCategoriesCheckBox->isChecked();
		994	}
		995
		996	void MainWindow::series1CheckBoxChecked()
		997	{
		998	if (ui->series1checkBox->isChecked())
		999	m_series1->setVisible(true);
		1000	else
		1001	m_series1->setVisible(false);
		1002	}
		1003
		1004	void MainWindow::series2CheckBoxChecked()
		1005	{
		1006	if (ui->series2checkBox->isChecked())
		1007	m_series2->setVisible(true);
		1008	else
		1009	m_series2->setVisible(false);
		1010	}
		1011
		1012	void MainWindow::series3CheckBoxChecked()
		1013	{
		1014	if (ui->series3checkBox->isChecked())
		1015	m_series3->setVisible(true);
		1016	else
		1017	m_series3->setVisible(false);
		1018	}
		1019
		1020	void MainWindow::series4CheckBoxChecked()
		1021	{
		1022	if (ui->series4checkBox->isChecked())
		1023	m_series4->setVisible(true);
		1024	else
		1025	m_series4->setVisible(false);
		1026	}
		1027
		1028	void MainWindow::series5CheckBoxChecked()
		1029	{
		1030	if (ui->series5checkBox->isChecked())
		1031	m_series5->setVisible(true);
		1032	else
		1033	m_series5->setVisible(false);
		1034	}
		1035
		1036	void MainWindow::series6CheckBoxChecked()
		1037	{
		1038	if (ui->series6checkBox->isChecked())
		1039	m_series6->setVisible(true);
		1040	else
		1041	m_series6->setVisible(false);
		1042	}
		1043
		1044	void MainWindow::series7CheckBoxChecked()
		1045	{
		1046	if (ui->series7checkBox->isChecked())
		1047	m_series7->setVisible(true);
		1048	else
		1049	m_series7->setVisible(false);
		1050	}
		1051
		1052	void MainWindow::themeIndexChanged(int index)
		1053	{
		1054	m_chart->setTheme(QChart::ChartTheme(index));
		1055	}
		1056
		1057	void MainWindow::seriesHovered(QPointF point, bool state)
		1058	{
		1059	QAbstractSeries series = qobject_cast<QAbstractSeries >(sender());
		1060	if (series) {
		1061	if (state) {
		1062	QString str("'%3' - %1 x %2");
		1063	ui->hoverLabel->setText(str.arg(point.x()).arg(point.y()).arg(series->name()));
		1064	} else {
		1065	ui->hoverLabel->setText("No hover");
		1066	}
		1067	} else {
		1068	qDebug() << "seriesHovered - invalid sender!";
		1069	}
		1070	}
		1071
		1072	void MainWindow::seriesClicked(const QPointF &point)
		1073	{
		1074	QAbstractSeries series = qobject_cast<QAbstractSeries >(sender());
		1075	if (series) {
		1076	QString str("'%3' clicked at: %1 x %2");
		1077	m_angularTitle = str.arg(point.x()).arg(point.y()).arg(series->name());
		1078	m_angularAxis->setTitleText(m_angularTitle);
		1079	} else {
		1080	qDebug() << "seriesClicked - invalid sender!";
		1081	}
		1082	}
		1083
		1084	void MainWindow::applyCategories()
		1085	{
		1086	// Basic layout is three categories, extended has five
		1087	if (m_angularAxisMode == AxisModeCategory) {
		1088	QCategoryAxis angCatAxis = static_cast<QCategoryAxis >(m_angularAxis);
		1089	if (angCatAxis->count() == 0) {
		1090	angCatAxis->setStartValue(4000);
		1091	angCatAxis->append("Category A", 7000);
		1092	angCatAxis->append("Category B", 12000);
		1093	angCatAxis->append("Category C", 17000);
		1094	}
		1095	if (angCatAxis->count() == 3 && ui->moreCategoriesCheckBox->isChecked()) {
		1096	angCatAxis->setStartValue(1000);
		1097	angCatAxis->replaceLabel("Category A", "Cat A");
		1098	angCatAxis->replaceLabel("Category B", "Cat B");
		1099	angCatAxis->replaceLabel("Category C", "Cat C");
		1100	angCatAxis->append("Cat D", 22000);
		1101	angCatAxis->append("Cat E", 28000);
		1102	} else if (angCatAxis->count() == 5 && !ui->moreCategoriesCheckBox->isChecked()) {
		1103	angCatAxis->setStartValue(4000);
		1104	angCatAxis->replaceLabel("Cat A", "Category A");
		1105	angCatAxis->replaceLabel("Cat B", "Category B");
		1106	angCatAxis->replaceLabel("Cat C", "Category C");
		1107	angCatAxis->remove("Cat D");
		1108	angCatAxis->remove("Cat E");
		1109	}
		1110	}
		1111
		1112	if (m_radialAxisMode == AxisModeCategory) {
		1113	QCategoryAxis radCatAxis = static_cast<QCategoryAxis >(m_radialAxis);
		1114	if (radCatAxis->count() == 0) {
		1115	radCatAxis->setStartValue(2000);
		1116	radCatAxis->append("Category 1", 4000);
		1117	radCatAxis->append("Category 2", 9000);
		1118	radCatAxis->append("Category 3", 14000);
		1119	}
		1120	if (radCatAxis->count() == 3 && ui->moreCategoriesCheckBox->isChecked()) {
		1121	radCatAxis->setStartValue(1000);
		1122	radCatAxis->replaceLabel("Category 1", "Cat 1");
		1123	radCatAxis->replaceLabel("Category 2", "Cat 2");
		1124	radCatAxis->replaceLabel("Category 3", "Cat 3");
		1125	radCatAxis->append("Cat 4", 16500);
		1126	radCatAxis->append("Cat 5", 19000);
		1127	} else if (radCatAxis->count() == 5 && !ui->moreCategoriesCheckBox->isChecked()) {
		1128	radCatAxis->setStartValue(2000);
		1129	radCatAxis->replaceLabel("Cat 1", "Category 1");
		1130	radCatAxis->replaceLabel("Cat 2", "Category 2");
		1131	radCatAxis->replaceLabel("Cat 3", "Category 3");
		1132	radCatAxis->remove("Cat 4");
		1133	radCatAxis->remove("Cat 5");
		1134	}
		1135	}
		1136	}

tests/polarcharttest/mainwindow.h created 644 +155 0

@@ -0,0 +1,155
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2013 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#ifndef MAINWINDOW_H
	22	#define MAINWINDOW_H
	23
	24	#include <QPolarChart>
	25	#include <QMainWindow>
	26	#include <QFont>
	27	#include <QChart>
	28	#include <QScatterSeries>
	29	#include <QLineSeries>
	30	#include <QSplineSeries>
	31	#include <QAreaSeries>
	32
	33	namespace Ui {
	34	class MainWindow;
	35	}
	36
	37	QTCOMMERCIALCHART_USE_NAMESPACE
	38
	39	class QBrush;
	40	class QPen;
	41
	42	class MainWindow : public QMainWindow
	43	{
	44	Q_OBJECT
	45
	46	public:
	47	explicit MainWindow(QWidget *parent = 0);
	48	~MainWindow();
	49
	50	public slots:
	51	void angularTicksChanged(int value);
	52	void radialTicksChanged(int value);
	53	void anglesChanged(int value);
	54	void angularMinChanged(double value);
	55	void angularMaxChanged(double value);
	56	void radialMinChanged(double value);
	57	void radialMaxChanged(double value);
	58	void angularShadesIndexChanged(int index);
	59	void radialShadesIndexChanged(int index);
	60	void labelFormatEdited(const QString &text);
	61	void labelFontChanged(const QFont &font);
	62	void labelFontSizeChanged(int value);
	63	void animationIndexChanged(int index);
	64	void labelsIndexChanged(int index);
	65	void titleIndexChanged(int index);
	66	void titleFontChanged(const QFont &font);
	67	void titleFontSizeChanged(int value);
	68	void gridIndexChanged(int index);
	69	void arrowIndexChanged(int index);
	70	void angularRangeChanged(qreal min, qreal max);
	71	void radialRangeChanged(qreal min, qreal max);
	72	void angularAxisIndexChanged(int index);
	73	void radialAxisIndexChanged(int index);
	74	void logBaseChanged(double value);
	75	void niceNumbersChecked();
	76	void dateFormatEdited(const QString &text);
	77	void moreCategoriesChecked();
	78	void series1CheckBoxChecked();
	79	void series2CheckBoxChecked();
	80	void series3CheckBoxChecked();
	81	void series4CheckBoxChecked();
	82	void series5CheckBoxChecked();
	83	void series6CheckBoxChecked();
	84	void series7CheckBoxChecked();
	85	void themeIndexChanged(int index);
	86	void seriesHovered(QPointF point, bool state);
	87	void seriesClicked(const QPointF &point);
	88
	89	private:
	90	enum AxisMode {
	91	AxisModeNone,
	92	AxisModeValue,
	93	AxisModeLogValue,
	94	AxisModeDateTime,
	95	AxisModeCategory
	96	};
	97
	98	void initXYValueChart();
	99	void setAngularAxis(AxisMode mode);
	100	void setRadialAxis(AxisMode mode);
	101
	102	void applyRanges();
	103	void applyCategories();
	104
	105	Ui::MainWindow *ui;
	106
	107	int m_angularTickCount;
	108	int m_radialTickCount;
	109	qreal m_labelsAngle;
	110	qreal m_angularMin;
	111	qreal m_angularMax;
	112	qreal m_radialMin;
	113	qreal m_radialMax;
	114	bool m_angularShadesVisible;
	115	bool m_radialShadesVisible;
	116	bool m_labelsVisible;
	117	bool m_titleVisible;
	118	bool m_gridVisible;
	119	bool m_arrowVisible;
	120	QBrush *m_angularShadesBrush;
	121	QBrush *m_radialShadesBrush;
	122	QBrush *m_labelBrush;
	123	QBrush *m_titleBrush;
	124	QPen *m_angularShadesPen;
	125	QPen *m_radialShadesPen;
	126	QPen *m_labelPen;
	127	QPen *m_titlePen;
	128	QPen *m_gridPen;
	129	QPen *m_arrowPen;
	130	QString m_labelFormat;
	131	QFont m_currentLabelFont;
	132	QFont m_currentTitleFont;
	133	QChart::AnimationOptions m_animationOptions;
	134	QString m_angularTitle;
	135	QString m_radialTitle;
	136	qreal m_base;
	137	QString m_dateFormat;
	138
	139	QPolarChart *m_chart;
	140	QAbstractAxis *m_angularAxis;
	141	QAbstractAxis *m_radialAxis;
	142	AxisMode m_angularAxisMode;
	143	AxisMode m_radialAxisMode;
	144	bool m_moreCategories;
	145
	146	QScatterSeries *m_series1;
	147	QLineSeries *m_series2;
	148	QLineSeries *m_series3;
	149	QLineSeries *m_series4;
	150	QAreaSeries *m_series5;
	151	QSplineSeries *m_series6;
	152	QScatterSeries *m_series7;
	153	};
	154
	155	#endif // MAINWINDOW_H

tests/polarcharttest/mainwindow.ui created 644 +929 0

This diff has been collapsed as it changes many lines, (929 lines changed) Show them Hide them
	@@ -0,0 +1,929
		1	<?xml version="1.0" encoding="UTF-8"?>
		2	<ui version="4.0">
		3	<class>MainWindow</class>
		4	<widget class="QMainWindow" name="MainWindow">
		5	<property name="geometry">
		6	<rect>
		7	<x>0</x>
		8	<y>0</y>
		9	<width>1207</width>
		10	<height>905</height>
		11	</rect>
		12	</property>
		13	<property name="windowTitle">
		14	<string>MainWindow</string>
		15	</property>
		16	<widget class="QWidget" name="centralWidget">
		17	<layout class="QHBoxLayout" name="horizontalLayout">
		18	<item>
		19	<widget class="ChartView" name="chartView"/>
		20	</item>
		21	<item>
		22	<widget class="QGroupBox" name="settingsBox">
		23	<property name="sizePolicy">
		24	<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
		25	<horstretch>0</horstretch>
		26	<verstretch>0</verstretch>
		27	</sizepolicy>
		28	</property>
		29	<property name="minimumSize">
		30	<size>
		31	<width>200</width>
		32	<height>0</height>
		33	</size>
		34	</property>
		35	<property name="title">
		36	<string>Settings</string>
		37	</property>
		38	<widget class="QSpinBox" name="radialTicksSpin">
		39	<property name="geometry">
		40	<rect>
		41	<x>110</x>
		42	<y>90</y>
		43	<width>71</width>
		44	<height>22</height>
		45	</rect>
		46	</property>
		47	</widget>
		48	<widget class="QLabel" name="label">
		49	<property name="geometry">
		50	<rect>
		51	<x>10</x>
		52	<y>90</y>
		53	<width>101</width>
		54	<height>16</height>
		55	</rect>
		56	</property>
		57	<property name="text">
		58	<string>Radial Tick count</string>
		59	</property>
		60	</widget>
		61	<widget class="QLabel" name="label_2">
		62	<property name="geometry">
		63	<rect>
		64	<x>10</x>
		65	<y>120</y>
		66	<width>101</width>
		67	<height>16</height>
		68	</rect>
		69	</property>
		70	<property name="text">
		71	<string>Angular Tick count</string>
		72	</property>
		73	</widget>
		74	<widget class="QSpinBox" name="angularTicksSpin">
		75	<property name="geometry">
		76	<rect>
		77	<x>110</x>
		78	<y>120</y>
		79	<width>71</width>
		80	<height>22</height>
		81	</rect>
		82	</property>
		83	</widget>
		84	<widget class="QSpinBox" name="anglesSpin">
		85	<property name="geometry">
		86	<rect>
		87	<x>110</x>
		88	<y>150</y>
		89	<width>71</width>
		90	<height>22</height>
		91	</rect>
		92	</property>
		93	<property name="minimum">
		94	<number>-9999</number>
		95	</property>
		96	<property name="maximum">
		97	<number>9999</number>
		98	</property>
		99	<property name="singleStep">
		100	<number>5</number>
		101	</property>
		102	</widget>
		103	<widget class="QLabel" name="label_3">
		104	<property name="geometry">
		105	<rect>
		106	<x>10</x>
		107	<y>150</y>
		108	<width>101</width>
		109	<height>16</height>
		110	</rect>
		111	</property>
		112	<property name="text">
		113	<string>Label angles</string>
		114	</property>
		115	</widget>
		116	<widget class="QLabel" name="label_4">
		117	<property name="geometry">
		118	<rect>
		119	<x>10</x>
		120	<y>180</y>
		121	<width>101</width>
		122	<height>16</height>
		123	</rect>
		124	</property>
		125	<property name="text">
		126	<string>Angular min</string>
		127	</property>
		128	</widget>
		129	<widget class="QLabel" name="label_5">
		130	<property name="geometry">
		131	<rect>
		132	<x>10</x>
		133	<y>210</y>
		134	<width>101</width>
		135	<height>16</height>
		136	</rect>
		137	</property>
		138	<property name="text">
		139	<string>Angular max</string>
		140	</property>
		141	</widget>
		142	<widget class="QDoubleSpinBox" name="angularMinSpin">
		143	<property name="geometry">
		144	<rect>
		145	<x>90</x>
		146	<y>180</y>
		147	<width>91</width>
		148	<height>22</height>
		149	</rect>
		150	</property>
		151	<property name="decimals">
		152	<number>5</number>
		153	</property>
		154	<property name="minimum">
		155	<double>-999999999.000000000000000</double>
		156	</property>
		157	<property name="maximum">
		158	<double>999999999.000000000000000</double>
		159	</property>
		160	<property name="singleStep">
		161	<double>10.000000000000000</double>
		162	</property>
		163	</widget>
		164	<widget class="QDoubleSpinBox" name="angularMaxSpin">
		165	<property name="geometry">
		166	<rect>
		167	<x>90</x>
		168	<y>210</y>
		169	<width>91</width>
		170	<height>22</height>
		171	</rect>
		172	</property>
		173	<property name="decimals">
		174	<number>5</number>
		175	</property>
		176	<property name="minimum">
		177	<double>-999999999.000000000000000</double>
		178	</property>
		179	<property name="maximum">
		180	<double>999999999.000000000000000</double>
		181	</property>
		182	<property name="singleStep">
		183	<double>10.000000000000000</double>
		184	</property>
		185	</widget>
		186	<widget class="QDoubleSpinBox" name="radialMaxSpin">
		187	<property name="geometry">
		188	<rect>
		189	<x>90</x>
		190	<y>270</y>
		191	<width>91</width>
		192	<height>22</height>
		193	</rect>
		194	</property>
		195	<property name="decimals">
		196	<number>5</number>
		197	</property>
		198	<property name="minimum">
		199	<double>-999999999.000000000000000</double>
		200	</property>
		201	<property name="maximum">
		202	<double>999999999.000000000000000</double>
		203	</property>
		204	<property name="singleStep">
		205	<double>10.000000000000000</double>
		206	</property>
		207	</widget>
		208	<widget class="QDoubleSpinBox" name="radialMinSpin">
		209	<property name="geometry">
		210	<rect>
		211	<x>90</x>
		212	<y>240</y>
		213	<width>91</width>
		214	<height>22</height>
		215	</rect>
		216	</property>
		217	<property name="decimals">
		218	<number>5</number>
		219	</property>
		220	<property name="minimum">
		221	<double>-999999999.000000000000000</double>
		222	</property>
		223	<property name="maximum">
		224	<double>999999999.000000000000000</double>
		225	</property>
		226	<property name="singleStep">
		227	<double>10.000000000000000</double>
		228	</property>
		229	</widget>
		230	<widget class="QLabel" name="label_11">
		231	<property name="geometry">
		232	<rect>
		233	<x>10</x>
		234	<y>270</y>
		235	<width>101</width>
		236	<height>16</height>
		237	</rect>
		238	</property>
		239	<property name="text">
		240	<string>Radial max</string>
		241	</property>
		242	</widget>
		243	<widget class="QLabel" name="label_12">
		244	<property name="geometry">
		245	<rect>
		246	<x>10</x>
		247	<y>240</y>
		248	<width>101</width>
		249	<height>16</height>
		250	</rect>
		251	</property>
		252	<property name="text">
		253	<string>Radial min</string>
		254	</property>
		255	</widget>
		256	<widget class="QComboBox" name="angularShadesComboBox">
		257	<property name="geometry">
		258	<rect>
		259	<x>10</x>
		260	<y>300</y>
		261	<width>171</width>
		262	<height>22</height>
		263	</rect>
		264	</property>
		265	<item>
		266	<property name="text">
		267	<string>No angular shades</string>
		268	</property>
		269	</item>
		270	<item>
		271	<property name="text">
		272	<string>Gray angular shades</string>
		273	</property>
		274	</item>
		275	<item>
		276	<property name="text">
		277	<string>Yellow ang. shades + custom pen</string>
		278	</property>
		279	</item>
		280	</widget>
		281	<widget class="QComboBox" name="radialShadesComboBox">
		282	<property name="geometry">
		283	<rect>
		284	<x>10</x>
		285	<y>330</y>
		286	<width>171</width>
		287	<height>22</height>
		288	</rect>
		289	</property>
		290	<item>
		291	<property name="text">
		292	<string>No radial shades</string>
		293	</property>
		294	</item>
		295	<item>
		296	<property name="text">
		297	<string>Green radial shades</string>
		298	</property>
		299	</item>
		300	<item>
		301	<property name="text">
		302	<string>Blue rad. shades + custom pen</string>
		303	</property>
		304	</item>
		305	</widget>
		306	<widget class="QLabel" name="label_13">
		307	<property name="geometry">
		308	<rect>
		309	<x>10</x>
		310	<y>360</y>
		311	<width>101</width>
		312	<height>16</height>
		313	</rect>
		314	</property>
		315	<property name="text">
		316	<string>Label format</string>
		317	</property>
		318	</widget>
		319	<widget class="QLineEdit" name="labelFormatEdit">
		320	<property name="geometry">
		321	<rect>
		322	<x>100</x>
		323	<y>360</y>
		324	<width>81</width>
		325	<height>20</height>
		326	</rect>
		327	</property>
		328	</widget>
		329	<widget class="QLabel" name="label_14">
		330	<property name="geometry">
		331	<rect>
		332	<x>10</x>
		333	<y>390</y>
		334	<width>101</width>
		335	<height>16</height>
		336	</rect>
		337	</property>
		338	<property name="text">
		339	<string>Label font size</string>
		340	</property>
		341	</widget>
		342	<widget class="QFontComboBox" name="labelFontComboBox">
		343	<property name="geometry">
		344	<rect>
		345	<x>10</x>
		346	<y>420</y>
		347	<width>171</width>
		348	<height>22</height>
		349	</rect>
		350	</property>
		351	</widget>
		352	<widget class="QSpinBox" name="labelFontSizeSpin">
		353	<property name="geometry">
		354	<rect>
		355	<x>100</x>
		356	<y>390</y>
		357	<width>81</width>
		358	<height>22</height>
		359	</rect>
		360	</property>
		361	<property name="minimum">
		362	<number>-100000</number>
		363	</property>
		364	<property name="maximum">
		365	<number>100000</number>
		366	</property>
		367	</widget>
		368	<widget class="QComboBox" name="animationsComboBox">
		369	<property name="geometry">
		370	<rect>
		371	<x>10</x>
		372	<y>480</y>
		373	<width>171</width>
		374	<height>22</height>
		375	</rect>
		376	</property>
		377	<item>
		378	<property name="text">
		379	<string>No animations</string>
		380	</property>
		381	</item>
		382	<item>
		383	<property name="text">
		384	<string>Series animation</string>
		385	</property>
		386	</item>
		387	<item>
		388	<property name="text">
		389	<string>Grid animation</string>
		390	</property>
		391	</item>
		392	<item>
		393	<property name="text">
		394	<string>All animations</string>
		395	</property>
		396	</item>
		397	</widget>
		398	<widget class="QComboBox" name="labelComboBox">
		399	<property name="geometry">
		400	<rect>
		401	<x>10</x>
		402	<y>450</y>
		403	<width>171</width>
		404	<height>22</height>
		405	</rect>
		406	</property>
		407	<property name="currentIndex">
		408	<number>1</number>
		409	</property>
		410	<item>
		411	<property name="text">
		412	<string>No labels</string>
		413	</property>
		414	</item>
		415	<item>
		416	<property name="text">
		417	<string>Black label</string>
		418	</property>
		419	</item>
		420	<item>
		421	<property name="text">
		422	<string>White label + blue pen</string>
		423	</property>
		424	</item>
		425	</widget>
		426	<widget class="QSpinBox" name="titleFontSizeSpin">
		427	<property name="geometry">
		428	<rect>
		429	<x>100</x>
		430	<y>510</y>
		431	<width>81</width>
		432	<height>22</height>
		433	</rect>
		434	</property>
		435	<property name="minimum">
		436	<number>-100000</number>
		437	</property>
		438	<property name="maximum">
		439	<number>100000</number>
		440	</property>
		441	</widget>
		442	<widget class="QComboBox" name="titleComboBox">
		443	<property name="geometry">
		444	<rect>
		445	<x>10</x>
		446	<y>570</y>
		447	<width>171</width>
		448	<height>22</height>
		449	</rect>
		450	</property>
		451	<property name="sizePolicy">
		452	<sizepolicy hsizetype="Fixed" vsizetype="Fixed">
		453	<horstretch>0</horstretch>
		454	<verstretch>0</verstretch>
		455	</sizepolicy>
		456	</property>
		457	<property name="currentIndex">
		458	<number>3</number>
		459	</property>
		460	<item>
		461	<property name="text">
		462	<string>Invisible empty title</string>
		463	</property>
		464	</item>
		465	<item>
		466	<property name="text">
		467	<string>Visible empty title</string>
		468	</property>
		469	</item>
		470	<item>
		471	<property name="text">
		472	<string>Invisible title</string>
		473	</property>
		474	</item>
		475	<item>
		476	<property name="text">
		477	<string>Black title</string>
		478	</property>
		479	</item>
		480	<item>
		481	<property name="text">
		482	<string>White title + blue pen</string>
		483	</property>
		484	</item>
		485	</widget>
		486	<widget class="QFontComboBox" name="titleFontComboBox">
		487	<property name="geometry">
		488	<rect>
		489	<x>10</x>
		490	<y>540</y>
		491	<width>171</width>
		492	<height>22</height>
		493	</rect>
		494	</property>
		495	</widget>
		496	<widget class="QLabel" name="label_15">
		497	<property name="geometry">
		498	<rect>
		499	<x>10</x>
		500	<y>510</y>
		501	<width>101</width>
		502	<height>16</height>
		503	</rect>
		504	</property>
		505	<property name="text">
		506	<string>Title font size</string>
		507	</property>
		508	</widget>
		509	<widget class="QComboBox" name="gridComboBox">
		510	<property name="geometry">
		511	<rect>
		512	<x>10</x>
		513	<y>600</y>
		514	<width>171</width>
		515	<height>22</height>
		516	</rect>
		517	</property>
		518	<property name="sizePolicy">
		519	<sizepolicy hsizetype="Fixed" vsizetype="Fixed">
		520	<horstretch>0</horstretch>
		521	<verstretch>0</verstretch>
		522	</sizepolicy>
		523	</property>
		524	<property name="currentIndex">
		525	<number>1</number>
		526	</property>
		527	<item>
		528	<property name="text">
		529	<string>Invisible grid</string>
		530	</property>
		531	</item>
		532	<item>
		533	<property name="text">
		534	<string>Black grid</string>
		535	</property>
		536	</item>
		537	<item>
		538	<property name="text">
		539	<string>Custom grid pen</string>
		540	</property>
		541	</item>
		542	</widget>
		543	<widget class="QComboBox" name="arrowComboBox">
		544	<property name="geometry">
		545	<rect>
		546	<x>10</x>
		547	<y>630</y>
		548	<width>171</width>
		549	<height>22</height>
		550	</rect>
		551	</property>
		552	<property name="sizePolicy">
		553	<sizepolicy hsizetype="Fixed" vsizetype="Fixed">
		554	<horstretch>0</horstretch>
		555	<verstretch>0</verstretch>
		556	</sizepolicy>
		557	</property>
		558	<property name="currentIndex">
		559	<number>1</number>
		560	</property>
		561	<item>
		562	<property name="text">
		563	<string>Invisible arrow</string>
		564	</property>
		565	</item>
		566	<item>
		567	<property name="text">
		568	<string>Black arrow</string>
		569	</property>
		570	</item>
		571	<item>
		572	<property name="text">
		573	<string>Custom arrow pen</string>
		574	</property>
		575	</item>
		576	</widget>
		577	<widget class="QComboBox" name="angularAxisComboBox">
		578	<property name="geometry">
		579	<rect>
		580	<x>10</x>
		581	<y>20</y>
		582	<width>171</width>
		583	<height>22</height>
		584	</rect>
		585	</property>
		586	<property name="currentIndex">
		587	<number>1</number>
		588	</property>
		589	<item>
		590	<property name="text">
		591	<string>No Angular Axis</string>
		592	</property>
		593	</item>
		594	<item>
		595	<property name="text">
		596	<string>Angular Value Axis</string>
		597	</property>
		598	</item>
		599	<item>
		600	<property name="text">
		601	<string>Angular Log Axis</string>
		602	</property>
		603	</item>
		604	<item>
		605	<property name="text">
		606	<string>Angular DateTime Axis</string>
		607	</property>
		608	</item>
		609	<item>
		610	<property name="text">
		611	<string>Angular Category Axis</string>
		612	</property>
		613	</item>
		614	</widget>
		615	<widget class="QComboBox" name="radialAxisComboBox">
		616	<property name="geometry">
		617	<rect>
		618	<x>10</x>
		619	<y>50</y>
		620	<width>171</width>
		621	<height>22</height>
		622	</rect>
		623	</property>
		624	<property name="currentIndex">
		625	<number>1</number>
		626	</property>
		627	<item>
		628	<property name="text">
		629	<string>No Radial Axis</string>
		630	</property>
		631	</item>
		632	<item>
		633	<property name="text">
		634	<string>Radial Value Axis</string>
		635	</property>
		636	</item>
		637	<item>
		638	<property name="text">
		639	<string>Radial Log Axis</string>
		640	</property>
		641	</item>
		642	<item>
		643	<property name="text">
		644	<string>Radial DateTime Axis</string>
		645	</property>
		646	</item>
		647	<item>
		648	<property name="text">
		649	<string>Radial Category Axis</string>
		650	</property>
		651	</item>
		652	</widget>
		653	<widget class="QLabel" name="label_16">
		654	<property name="geometry">
		655	<rect>
		656	<x>10</x>
		657	<y>660</y>
		658	<width>101</width>
		659	<height>16</height>
		660	</rect>
		661	</property>
		662	<property name="text">
		663	<string>Log Base</string>
		664	</property>
		665	</widget>
		666	<widget class="QDoubleSpinBox" name="logBaseSpin">
		667	<property name="geometry">
		668	<rect>
		669	<x>90</x>
		670	<y>660</y>
		671	<width>91</width>
		672	<height>22</height>
		673	</rect>
		674	</property>
		675	<property name="decimals">
		676	<number>5</number>
		677	</property>
		678	<property name="minimum">
		679	<double>-999999999.000000000000000</double>
		680	</property>
		681	<property name="maximum">
		682	<double>999999999.000000000000000</double>
		683	</property>
		684	<property name="value">
		685	<double>8.000000000000000</double>
		686	</property>
		687	</widget>
		688	<widget class="QCheckBox" name="niceNumbersCheckBox">
		689	<property name="geometry">
		690	<rect>
		691	<x>10</x>
		692	<y>690</y>
		693	<width>91</width>
		694	<height>16</height>
		695	</rect>
		696	</property>
		697	<property name="text">
		698	<string>Nice Numbers</string>
		699	</property>
		700	</widget>
		701	<widget class="QLineEdit" name="dateFormatEdit">
		702	<property name="geometry">
		703	<rect>
		704	<x>100</x>
		705	<y>710</y>
		706	<width>81</width>
		707	<height>20</height>
		708	</rect>
		709	</property>
		710	</widget>
		711	<widget class="QLabel" name="label_17">
		712	<property name="geometry">
		713	<rect>
		714	<x>10</x>
		715	<y>710</y>
		716	<width>101</width>
		717	<height>16</height>
		718	</rect>
		719	</property>
		720	<property name="text">
		721	<string>DateTime format</string>
		722	</property>
		723	</widget>
		724	<widget class="QCheckBox" name="moreCategoriesCheckBox">
		725	<property name="geometry">
		726	<rect>
		727	<x>100</x>
		728	<y>690</y>
		729	<width>141</width>
		730	<height>16</height>
		731	</rect>
		732	</property>
		733	<property name="text">
		734	<string>More Categories</string>
		735	</property>
		736	</widget>
		737	<widget class="QCheckBox" name="series1checkBox">
		738	<property name="geometry">
		739	<rect>
		740	<x>10</x>
		741	<y>730</y>
		742	<width>31</width>
		743	<height>16</height>
		744	</rect>
		745	</property>
		746	<property name="text">
		747	<string>1</string>
		748	</property>
		749	</widget>
		750	<widget class="QCheckBox" name="series2checkBox">
		751	<property name="geometry">
		752	<rect>
		753	<x>40</x>
		754	<y>730</y>
		755	<width>31</width>
		756	<height>16</height>
		757	</rect>
		758	</property>
		759	<property name="text">
		760	<string>2</string>
		761	</property>
		762	</widget>
		763	<widget class="QCheckBox" name="series3checkBox">
		764	<property name="geometry">
		765	<rect>
		766	<x>70</x>
		767	<y>730</y>
		768	<width>31</width>
		769	<height>16</height>
		770	</rect>
		771	</property>
		772	<property name="text">
		773	<string>3</string>
		774	</property>
		775	</widget>
		776	<widget class="QCheckBox" name="series4checkBox">
		777	<property name="geometry">
		778	<rect>
		779	<x>10</x>
		780	<y>750</y>
		781	<width>31</width>
		782	<height>16</height>
		783	</rect>
		784	</property>
		785	<property name="text">
		786	<string>4</string>
		787	</property>
		788	</widget>
		789	<widget class="QCheckBox" name="series5checkBox">
		790	<property name="geometry">
		791	<rect>
		792	<x>40</x>
		793	<y>750</y>
		794	<width>31</width>
		795	<height>16</height>
		796	</rect>
		797	</property>
		798	<property name="text">
		799	<string>5</string>
		800	</property>
		801	</widget>
		802	<widget class="QCheckBox" name="series6checkBox">
		803	<property name="geometry">
		804	<rect>
		805	<x>70</x>
		806	<y>750</y>
		807	<width>31</width>
		808	<height>16</height>
		809	</rect>
		810	</property>
		811	<property name="text">
		812	<string>6</string>
		813	</property>
		814	</widget>
		815	<widget class="QCheckBox" name="series7checkBox">
		816	<property name="geometry">
		817	<rect>
		818	<x>100</x>
		819	<y>740</y>
		820	<width>31</width>
		821	<height>16</height>
		822	</rect>
		823	</property>
		824	<property name="text">
		825	<string>7</string>
		826	</property>
		827	</widget>
		828	<widget class="QComboBox" name="themeComboBox">
		829	<property name="geometry">
		830	<rect>
		831	<x>10</x>
		832	<y>770</y>
		833	<width>171</width>
		834	<height>22</height>
		835	</rect>
		836	</property>
		837	<property name="sizePolicy">
		838	<sizepolicy hsizetype="Fixed" vsizetype="Fixed">
		839	<horstretch>0</horstretch>
		840	<verstretch>0</verstretch>
		841	</sizepolicy>
		842	</property>
		843	<property name="currentIndex">
		844	<number>0</number>
		845	</property>
		846	<item>
		847	<property name="text">
		848	<string>Theme: Light</string>
		849	</property>
		850	</item>
		851	<item>
		852	<property name="text">
		853	<string>Theme: Blue Cerulean</string>
		854	</property>
		855	</item>
		856	<item>
		857	<property name="text">
		858	<string>Theme: Dark</string>
		859	</property>
		860	</item>
		861	<item>
		862	<property name="text">
		863	<string>Theme: Brown Sand</string>
		864	</property>
		865	</item>
		866	<item>
		867	<property name="text">
		868	<string>Theme: Blue Ncs</string>
		869	</property>
		870	</item>
		871	<item>
		872	<property name="text">
		873	<string>Theme: High Contrast</string>
		874	</property>
		875	</item>
		876	<item>
		877	<property name="text">
		878	<string>Theme: Blue Icy</string>
		879	</property>
		880	</item>
		881	</widget>
		882	<widget class="QLabel" name="hoverLabel">
		883	<property name="geometry">
		884	<rect>
		885	<x>10</x>
		886	<y>800</y>
		887	<width>171</width>
		888	<height>16</height>
		889	</rect>
		890	</property>
		891	<property name="text">
		892	<string>Hover coordinates here!</string>
		893	</property>
		894	</widget>
		895	</widget>
		896	</item>
		897	</layout>
		898	</widget>
		899	<widget class="QMenuBar" name="menuBar">
		900	<property name="geometry">
		901	<rect>
		902	<x>0</x>
		903	<y>0</y>
		904	<width>1207</width>
		905	<height>21</height>
		906	</rect>
		907	</property>
		908	</widget>
		909	<widget class="QToolBar" name="mainToolBar">
		910	<attribute name="toolBarArea">
		911	<enum>TopToolBarArea</enum>
		912	</attribute>
		913	<attribute name="toolBarBreak">
		914	<bool>false</bool>
		915	</attribute>
		916	</widget>
		917	<widget class="QStatusBar" name="statusBar"/>
		918	</widget>
		919	<layoutdefault spacing="6" margin="11"/>
		920	<customwidgets>
		921	<customwidget>
		922	<class>ChartView</class>
		923	<extends>QGraphicsView</extends>
		924	<header>chartview.h</header>
		925	</customwidget>
		926	</customwidgets>
		927	<resources/>
		928	<connections/>
		929	</ui>

tests/polarcharttest/polarcharttest.pro created 644 +20 0

@@ -0,0 +1,20
	1	!include( ../tests.pri ) {
	2	error( "Couldn't find the test.pri file!" )
	3	}
	4
	5	QT += core gui
	6
	7	greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
	8
	9	TARGET = polarcharttest
	10	TEMPLATE = app
	11
	12
	13	SOURCES += main.cpp \
	14	mainwindow.cpp \
	15	chartview.cpp
	16
	17	HEADERS += mainwindow.h \
	18	chartview.h
	19
	20	FORMS += mainwindow.ui

demos/chartinteractions/chart.cpp +1 -1

             #include <cmath>
             Chart::Chart(QGraphicsItem *parent, Qt::WindowFlags wFlags, QLineSeries *series)
-                : QChart(parent, wFlags), m_series(series)
+                : QChart(QChart::ChartTypeCartesian, parent, wFlags), m_series(series)
             {
                 m_clicked = false;
             }

demos/demos.pro +2 -1

                        chartinteractions \
                        qmlaxes \
                        qmlcustomlegend \
-                       callout
+                       callout \
+                       qmlpolarchart
             contains(QT_CONFIG, opengl) {
                     SUBDIRS +=  chartthemes \

demos/dynamicspline/chart.cpp +1 -1

             #include <QDebug>
             Chart::Chart(QGraphicsItem *parent, Qt::WindowFlags wFlags):
-                QChart(parent, wFlags),
+                QChart(QChart::ChartTypeCartesian, parent, wFlags),
                 m_series(0),
                 m_axis(new QValueAxis),
                 m_step(0),

doc/src/classes.qdoc +1 0

                             <td valign="top">
                                 <ul>
                                 <li><a href="qchart.html">QChart</a></li>
+                                <li><a href="qpolarchart.html">QPolarChart</a></li>
                                 <li><a href="qchartview.html">QChartView</a></li>
                                 <li><a href="qabstractaxis.html">QAbstractAxis</a></li>
                                 <li><a href="qvalueaxis.html">QValueAxis</a></li>

doc/src/demos.qdoc +10 -10

                 <table>
                     <tr>
+                        <td><a href="demos-audio.html">Audio</a></td>
+                        <td><a href="demos-callout.html">Callout</a></td>
+                    </tr>
+                    <tr>
+                        <td><a href="demos-audio.html"><img src="images/demos_audio.png" width="300" alt="Audio" /></a></td>
+                        <td><a href="demos-callout.html"><img src="images/demos_callout.png" width="300" alt="Callout" /></a></td>
+                    </tr>
+                    <tr>
                         <td><a href="demos-chartthemes.html">Chart Themes</a></td>
                         <td><a href="demos-dynamicspline.html">Dynamic Spline Chart</a></td>
                     </tr>
                         <td><a href="demos-chartthemes.html"><img src="images/demo_chartthemes_blue_cerulean.png" width="300" alt="Chart Themes" /></a></td>
                         <td><a href="demos-dynamicspline.html"><img src="images/demos_dynamicspline2.png" width="300" alt="Dynamic Spline" /></a></td>
                     </tr>
                     <tr>
                         <td><a href="demos-nesteddonuts.html">Nested Donuts Chart</a></td>
                         <td><a href="demos-piechartcustomization.html">Pie Chart Customization</a></td>
                         <td><a href="demos-nesteddonuts.html"><img src="images/demos_nesteddonuts.png" width="300" alt="Nested Donuts Chart" /></a></td>
                         <td><a href="demos-piechartcustomization.html"><img src="images/piechart_customization.png" width="300" alt="Pie Chart Customization" /></a></td>
                     </tr>
                     <tr>
                         <td><a href="demos-qmlchart.html">Qml Basic Charts</a></td>
                         <td><a href="demos-qmlaxes.html">Qml Axes</a></td>
                         <td><a href="demos-qmlchart.html"><img src="images/demos_qmlchart1.png" width="300" alt="Qml Basic Charts" /></a></td>
                         <td><a href="demos-qmlaxes.html"><img src="images/demos_qmlaxes1.png" width="300" alt="Qml Axes" /></a></td>
                     </tr>
                     <tr>
                         <td><a href="demos-qmlcustomizations.html">Qml Customizations</a></td>
                         <td><a href="demos-qmlcustommodel.html">Qml Custom Model</a></td>
                         <td><a href="demos-qmlcustomizations.html"><img src="images/demos_qmlcustomizations.png" width="300" alt="Qml Customizations" /></a></td>
                         <td><a href="demos-qmlcustommodel.html"><img src="images/demos_qmlcustommodel.png" width="300" alt="Qml Custom Model" /></a></td>
                     </tr>
                     <tr>
                         <td><a href="demos-qmlf1legends.html">Qml F1 Legends</a></td>
                         <td><a href="demos-qmloscilloscope.html">Qml Oscilloscope</a></td>
                         <td><a href="demos-qmlf1legends.html"><img src="images/demos_qmlf1legends.png" width="300" alt="Qml F1 Legends" /></a></td>
                         <td><a href="demos-qmloscilloscope.html"><img src="images/demos_qmloscilloscope.png" width="300" alt="Qml Oscilloscope" /></a></td>
                     </tr>
                     <tr>
                         <td><a href="demos-qmlweather.html">Qml Weather</a></td>
                         <td><a href="demos-qmlcustomlegend.html">Qml Custom Legend</a></td>
                         <td><a href="demos-qmlcustomlegend.html"><img src="images/demos-qmlcustomlegend1.png" width="300" alt="Qml Custom Legend" /></a></td>
                     </tr>
                     <tr>
-                        <td><a href="demos-callout.html">Callout</a></td>
+                        <td><a href="demos-qmlpolarchart.html">Qml Polar Chart</a></td>
-                        <td><a href="demos-audio.html">Audio</a></td>
                     </tr>
                     <tr>
-                        <td><a href="demos-callout.html"><img src="images/demos_callout.png" width="300" alt="Callout" /></a></td>
+                        <td><a href="demos-qmlpolarchart.html"><img src="images/demos_qmlpolarchart1.png" width="300" alt="Qml Polar Chart" /></a></td>
-                        <td><a href="demos-audio.html"><img src="images/demos_audio.png" width="300" alt="Audio" /></a></td>
                     </tr>
                 </table>
                 </div>
                 \endraw

doc/src/examples.qdoc +8 -6

                     </tr>
                     <tr>
+                        <td><a href="examples-polarchart.html">Polar chart</a></td>
                         <td><a href="examples-scatterchart.html">Scatter chart</a></td>
-                        <td><a href="examples-scatterinteractions.html">Scatter Interactions</a></td>
                     </tr>
                     <tr>
+                        <td><a href="examples-polarchart.html"><img src="images/examples_polarchart.png" width="300" alt="Polar chart" /></a></td>
                         <td><a href="examples-scatterchart.html"><img src="images/examples_scatterchart.png" width="300" alt="Scatter chart" /></a></td>
-                        <td><a href="examples-scatterinteractions.html"><img src="images/examples_scatterinteractions.png" width="300" alt="Scatter Interactions" /></a></td>
                     </tr>
                     <tr>
+                        <td><a href="examples-scatterinteractions.html">Scatter Interactions</a></td>
                         <td><a href="examples-splinechart.html">Spline Chart</a></td>
-                        <td><a href="examples-stackedbarchart.html">Stacked Bar Chart</a></td>
                     </tr>
                     <tr>
+                        <td><a href="examples-scatterinteractions.html"><img src="images/examples_scatterinteractions.png" width="300" alt="Scatter Interactions" /></a></td>
                         <td><a href="examples-splinechart.html"><img src="images/examples_splinechart.png" width="300" alt="Spline Chart" /></a></td>
-                        <td><a href="examples-stackedbarchart.html"><img src="images/examples_stackedbarchart.png" width="300" alt="Stacked Bar Chart" /></a></td>
                     </tr>
                     <tr>
+                        <td><a href="examples-stackedbarchart.html">Stacked Bar Chart</a></td>
                         <td><a href="examples-stackedbarchartdrilldown.html">Stacked Bar Chart Drilldown</a></td>
-                        <td><a href="examples-temperaturerecords.html">Temperature Records</a></td>
                     </tr>
                     <tr>
+                        <td><a href="examples-stackedbarchart.html"><img src="images/examples_stackedbarchart.png" width="300" alt="Stacked Bar Chart" /></a></td>
                         <td><a href="examples-stackedbarchartdrilldown.html"><img src="images/examples_stackedbarchartdrilldown1.png" width="300" alt="Stacked Bar Chart Drilldown" /></a></td>
-                        <td><a href="examples-temperaturerecords.html"><img src="images/examples_temperaturerecords.png" width="300" alt="Temperature Records" /></a></td>
                     </tr>
                     <tr>
+                        <td><a href="examples-temperaturerecords.html">Temperature Records</a></td>
                         <td><a href="examples-zoomlinechart.html">Zoom Line</a></td>
                     </tr>
                     <tr>
+                        <td><a href="examples-temperaturerecords.html"><img src="images/examples_temperaturerecords.png" width="300" alt="Temperature Records" /></a></td>
                         <td><a href="examples-zoomlinechart.html"><img src="images/examples_zoomlinechart1.png" width="300" alt="Zoom Line" /></a></td>
                     </tr>

doc/src/qml.qdoc +1 0

                             <td valign="top">
                                 <ul>
                                 <li><a href="qml-chartview.html">ChartView</a></li>
+                                <li><a href="qml-polarchartview.html">PolarChartView</a></li>
                                 <li><a href="qml-abstractaxis.html">AbstractAxis</a></li>
                                 <li><a href="qml-valueaxis.html">ValueAxis</a></li>
                                 <li><a href="qml-categoryaxis.html">CategoryAxis</a></li>

examples/donutbreakdown/donutbreakdownchart.cpp +1 -1

             //![1]
             DonutBreakdownChart::DonutBreakdownChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
-                : QChart(parent, wFlags)
+                : QChart(QChart::ChartTypeCartesian, parent, wFlags)
             {
                 // create the series for main center pie
                 m_mainSeries = new QPieSeries();

examples/examples.pro +2 -1

                        donutchart \
                        multiaxis \
                        legendmarkers \
-                       logvalueaxis
+                       logvalueaxis \
+                       polarchart
             !linux-arm*: {
             SUBDIRS += \

examples/piechartdrilldown/drilldownchart.cpp +1 -1

             QTCOMMERCIALCHART_USE_NAMESPACE
             DrilldownChart::DrilldownChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
-                : QChart(parent, wFlags),
+                : QChart(QChart::ChartTypeCartesian, parent, wFlags),
                   m_currentSeries(0)
             {

examples/stackedbarchartdrilldown/drilldownchart.cpp +1 -1

             QTCOMMERCIALCHART_USE_NAMESPACE
             DrilldownChart::DrilldownChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
-                : QChart(parent, wFlags),
+                : QChart(QChart::ChartTypeCartesian, parent, wFlags),
                   m_currentSeries(0)
             {
             }

examples/zoomlinechart/chart.cpp +1 -1

             #include <QGraphicsView>
             Chart::Chart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
-                : QChart(parent, wFlags)
+                : QChart(QChart::ChartTypeCartesian, parent, wFlags)
             {
                 // Seems that QGraphicsView (QChartView) does not grab gestures.
                 // They can only be grabbed here in the QGraphicsWidget (QChart).

plugins/declarative/declarative.pro +4 -2

                 declarativebarseries.cpp \
                 declarativecategoryaxis.cpp \
                 declarativemargins.cpp \
-                declarativeaxes.cpp
+                declarativeaxes.cpp \
+                declarativepolarchart.cpp
             HEADERS += \
                 declarativechart.h \
                 declarativebarseries.h \
                 declarativecategoryaxis.h \
                 declarativemargins.h \
-                declarativeaxes.h
+                declarativeaxes.h \
+                declarativepolarchart.h
             TARGETPATH = QtCommercial/Chart
             target.path = $$[QT_INSTALL_IMPORTS]/$$TARGETPATH

plugins/declarative/declarativeareaseries.cpp +2 0

                 connect(m_axes, SIGNAL(axisYChanged(QAbstractAxis*)), this, SIGNAL(axisYChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SIGNAL(axisXTopChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SIGNAL(axisYRightChanged(QAbstractAxis*)));
+                connect(m_axes, SIGNAL(axisXChanged(QAbstractAxis*)), this, SIGNAL(axisAngularChanged(QAbstractAxis*)));
+                connect(m_axes, SIGNAL(axisYChanged(QAbstractAxis*)), this, SIGNAL(axisRadialChanged(QAbstractAxis*)));
             }
             void DeclarativeAreaSeries::setUpperSeries(DeclarativeLineSeries *series)

plugins/declarative/declarativeareaseries.h +8 0

                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY NOTIFY axisYChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisXTop READ axisXTop WRITE setAxisXTop NOTIFY axisXTopChanged REVISION 2)
                 Q_PROPERTY(QAbstractAxis *axisYRight READ axisYRight WRITE setAxisYRight NOTIFY axisYRightChanged REVISION 2)
+                Q_PROPERTY(QAbstractAxis *axisAngular READ axisAngular WRITE setAxisAngular NOTIFY axisAngularChanged REVISION 3)
+                Q_PROPERTY(QAbstractAxis *axisRadial READ axisRadial WRITE setAxisRadial NOTIFY axisRadialChanged REVISION 3)
                 Q_PROPERTY(qreal borderWidth READ borderWidth WRITE setBorderWidth NOTIFY borderWidthChanged REVISION 1)
             public:
                 Q_REVISION(2) void setAxisXTop(QAbstractAxis *axis) { m_axes->setAxisXTop(axis); }
                 Q_REVISION(2) QAbstractAxis *axisYRight() { return m_axes->axisYRight(); }
                 Q_REVISION(2) void setAxisYRight(QAbstractAxis *axis) { m_axes->setAxisYRight(axis); }
+                Q_REVISION(3) QAbstractAxis *axisAngular() { return m_axes->axisX(); }
+                Q_REVISION(3) void setAxisAngular(QAbstractAxis *axis) { m_axes->setAxisX(axis); }
+                Q_REVISION(3) QAbstractAxis *axisRadial() { return m_axes->axisY(); }
+                Q_REVISION(3) void setAxisRadial(QAbstractAxis *axis) { m_axes->setAxisY(axis); }
                 qreal borderWidth() const;
                 void setBorderWidth(qreal borderWidth);
                 Q_REVISION(1) void borderWidthChanged(qreal width);
                 Q_REVISION(2) void axisXTopChanged(QAbstractAxis *axis);
                 Q_REVISION(2) void axisYRightChanged(QAbstractAxis *axis);
+                Q_REVISION(3) void axisAngularChanged(QAbstractAxis *axis);
+                Q_REVISION(3) void axisRadialChanged(QAbstractAxis *axis);
             public:
                 DeclarativeAxes *m_axes;

plugins/declarative/declarativechart.cpp +18 -2

@@ -35,6 +35,7
35	#include "chartdataset_p.h"	35	#include "chartdataset_p.h"
36	#include "declarativeaxes.h"	36	#include "declarativeaxes.h"
37	#include "qchart_p.h"	37	#include "qchart_p.h"
		38	#include "qpolarchart.h"
38		39
39	#ifndef QT_ON_ARM	40	#ifndef QT_ON_ARM
40	#include "qdatetimeaxis.h"	41	#include "qdatetimeaxis.h"
@@ -235,9 +236,24 QTCOMMERCIALCHART_BEGIN_NAMESPACE
235	*/	236	*/
236		237
237	DeclarativeChart::DeclarativeChart(QDeclarativeItem *parent)	238	DeclarativeChart::DeclarativeChart(QDeclarativeItem *parent)
238	: QDeclarativeItem(parent),	239	: QDeclarativeItem(parent)
239	m_chart(new QChart(this))
240	{	240	{
		241	initChart(QChart::ChartTypeCartesian);
		242	}
		243
		244	DeclarativeChart::DeclarativeChart(QChart::ChartType type, QDeclarativeItem *parent)
		245	: QDeclarativeItem(parent)
		246	{
		247	initChart(type);
		248	}
		249
		250	void DeclarativeChart::initChart(QChart::ChartType type)
		251	{
		252	if (type == QChart::ChartTypePolar)
		253	m_chart = new QPolarChart(this);
		254	else
		255	m_chart = new QChart(this);
		256
241	setFlag(QGraphicsItem::ItemHasNoContents, false);	257	setFlag(QGraphicsItem::ItemHasNoContents, false);
242	m_margins = new DeclarativeMargins(this);	258	m_margins = new DeclarativeMargins(this);
243	m_margins->setTop(m_chart->margins().top());	259	m_margins->setTop(m_chart->margins().top());

plugins/declarative/declarativechart.h +4 0

                 void handleAxisYRightSet(QAbstractAxis *axis);
                 void handleSeriesAdded(QAbstractSeries *series);
+            protected:
+                explicit DeclarativeChart(QChart::ChartType type, QDeclarativeItem *parent);
             private:
+                void initChart(QChart::ChartType type);
                 // 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;

plugins/declarative/declarativelineseries.cpp +2 0

                 connect(m_axes, SIGNAL(axisYChanged(QAbstractAxis*)), this, SIGNAL(axisYChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SIGNAL(axisXTopChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SIGNAL(axisYRightChanged(QAbstractAxis*)));
+                connect(m_axes, SIGNAL(axisXChanged(QAbstractAxis*)), this, SIGNAL(axisAngularChanged(QAbstractAxis*)));
+                connect(m_axes, SIGNAL(axisYChanged(QAbstractAxis*)), this, SIGNAL(axisRadialChanged(QAbstractAxis*)));
                 connect(this, SIGNAL(pointAdded(int)), this, SLOT(handleCountChanged(int)));
                 connect(this, SIGNAL(pointRemoved(int)), this, SLOT(handleCountChanged(int)));
             }

plugins/declarative/declarativelineseries.h +8 0

                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY NOTIFY axisYChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisXTop READ axisXTop WRITE setAxisXTop NOTIFY axisXTopChanged REVISION 2)
                 Q_PROPERTY(QAbstractAxis *axisYRight READ axisYRight WRITE setAxisYRight NOTIFY axisYRightChanged REVISION 2)
+                Q_PROPERTY(QAbstractAxis *axisAngular READ axisAngular WRITE setAxisAngular NOTIFY axisAngularChanged REVISION 3)
+                Q_PROPERTY(QAbstractAxis *axisRadial READ axisRadial WRITE setAxisRadial NOTIFY axisRadialChanged REVISION 3)
                 Q_PROPERTY(qreal width READ width WRITE setWidth NOTIFY widthChanged REVISION 1)
                 Q_PROPERTY(Qt::PenStyle style READ style WRITE setStyle NOTIFY styleChanged REVISION 1)
                 Q_PROPERTY(Qt::PenCapStyle capStyle READ capStyle WRITE setCapStyle NOTIFY capStyleChanged REVISION 1)
                 Q_REVISION(2) void setAxisXTop(QAbstractAxis *axis) { m_axes->setAxisXTop(axis); }
                 Q_REVISION(2) QAbstractAxis *axisYRight() { return m_axes->axisYRight(); }
                 Q_REVISION(2) void setAxisYRight(QAbstractAxis *axis) { m_axes->setAxisYRight(axis); }
+                Q_REVISION(3) QAbstractAxis *axisAngular() { return m_axes->axisX(); }
+                Q_REVISION(3) void setAxisAngular(QAbstractAxis *axis) { m_axes->setAxisX(axis); }
+                Q_REVISION(3) QAbstractAxis *axisRadial() { return m_axes->axisY(); }
+                Q_REVISION(3) void setAxisRadial(QAbstractAxis *axis) { m_axes->setAxisY(axis); }
                 qreal width() const;
                 void setWidth(qreal width);
                 Qt::PenStyle style() const;
                 Q_REVISION(1) void axisYChanged(QAbstractAxis *axis);
                 Q_REVISION(2) void axisXTopChanged(QAbstractAxis *axis);
                 Q_REVISION(2) void axisYRightChanged(QAbstractAxis *axis);
+                Q_REVISION(3) void axisAngularChanged(QAbstractAxis *axis);
+                Q_REVISION(3) void axisRadialChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void widthChanged(qreal width);
                 Q_REVISION(1) void styleChanged(Qt::PenStyle style);
                 Q_REVISION(1) void capStyleChanged(Qt::PenCapStyle capStyle);

plugins/declarative/declarativescatterseries.cpp +2 0

                 connect(m_axes, SIGNAL(axisYChanged(QAbstractAxis*)), this, SIGNAL(axisYChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SIGNAL(axisXTopChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SIGNAL(axisYRightChanged(QAbstractAxis*)));
+                connect(m_axes, SIGNAL(axisXChanged(QAbstractAxis*)), this, SIGNAL(axisAngularChanged(QAbstractAxis*)));
+                connect(m_axes, SIGNAL(axisYChanged(QAbstractAxis*)), this, SIGNAL(axisRadialChanged(QAbstractAxis*)));
                 connect(this, SIGNAL(pointAdded(int)), this, SLOT(handleCountChanged(int)));
                 connect(this, SIGNAL(pointRemoved(int)), this, SLOT(handleCountChanged(int)));
             }

plugins/declarative/declarativescatterseries.h +8 0

                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY NOTIFY axisYChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisXTop READ axisXTop WRITE setAxisXTop NOTIFY axisXTopChanged REVISION 2)
                 Q_PROPERTY(QAbstractAxis *axisYRight READ axisYRight WRITE setAxisYRight NOTIFY axisYRightChanged REVISION 2)
+                Q_PROPERTY(QAbstractAxis *axisAngular READ axisAngular WRITE setAxisAngular NOTIFY axisAngularChanged REVISION 3)
+                Q_PROPERTY(QAbstractAxis *axisRadial READ axisRadial WRITE setAxisRadial NOTIFY axisRadialChanged REVISION 3)
                 Q_PROPERTY(qreal borderWidth READ borderWidth WRITE setBorderWidth NOTIFY borderWidthChanged REVISION 1)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> declarativeChildren READ declarativeChildren)
                 Q_CLASSINFO("DefaultProperty", "declarativeChildren")
                 Q_REVISION(2) void setAxisXTop(QAbstractAxis *axis) { m_axes->setAxisXTop(axis); }
                 Q_REVISION(2) QAbstractAxis *axisYRight() { return m_axes->axisYRight(); }
                 Q_REVISION(2) void setAxisYRight(QAbstractAxis *axis) { m_axes->setAxisYRight(axis); }
+                Q_REVISION(3) QAbstractAxis *axisAngular() { return m_axes->axisX(); }
+                Q_REVISION(3) void setAxisAngular(QAbstractAxis *axis) { m_axes->setAxisX(axis); }
+                Q_REVISION(3) QAbstractAxis *axisRadial() { return m_axes->axisY(); }
+                Q_REVISION(3) void setAxisRadial(QAbstractAxis *axis) { m_axes->setAxisY(axis); }
                 qreal borderWidth() const;
                 void setBorderWidth(qreal borderWidth);
                 QDeclarativeListProperty<QObject> declarativeChildren();
                 Q_REVISION(1) void borderWidthChanged(qreal width);
                 Q_REVISION(2) void axisXTopChanged(QAbstractAxis *axis);
                 Q_REVISION(2) void axisYRightChanged(QAbstractAxis *axis);
+                Q_REVISION(3) void axisAngularChanged(QAbstractAxis *axis);
+                Q_REVISION(3) void axisRadialChanged(QAbstractAxis *axis);
             public Q_SLOTS:
                 static void appendDeclarativeChildren(QDeclarativeListProperty<QObject> *list, QObject *element);

plugins/declarative/declarativesplineseries.cpp +2 0

                 connect(m_axes, SIGNAL(axisYChanged(QAbstractAxis*)), this, SIGNAL(axisYChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SIGNAL(axisXTopChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SIGNAL(axisYRightChanged(QAbstractAxis*)));
+                connect(m_axes, SIGNAL(axisXChanged(QAbstractAxis*)), this, SIGNAL(axisAngularChanged(QAbstractAxis*)));
+                connect(m_axes, SIGNAL(axisYChanged(QAbstractAxis*)), this, SIGNAL(axisRadialChanged(QAbstractAxis*)));
                 connect(this, SIGNAL(pointAdded(int)), this, SLOT(handleCountChanged(int)));
                 connect(this, SIGNAL(pointRemoved(int)), this, SLOT(handleCountChanged(int)));
             }

plugins/declarative/declarativesplineseries.h +8 0

                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY NOTIFY axisYChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisXTop READ axisXTop WRITE setAxisXTop NOTIFY axisXTopChanged REVISION 2)
                 Q_PROPERTY(QAbstractAxis *axisYRight READ axisYRight WRITE setAxisYRight NOTIFY axisYRightChanged REVISION 2)
+                Q_PROPERTY(QAbstractAxis *axisAngular READ axisAngular WRITE setAxisAngular NOTIFY axisAngularChanged REVISION 3)
+                Q_PROPERTY(QAbstractAxis *axisRadial READ axisRadial WRITE setAxisRadial NOTIFY axisRadialChanged REVISION 3)
                 Q_PROPERTY(qreal width READ width WRITE setWidth NOTIFY widthChanged REVISION 1)
                 Q_PROPERTY(Qt::PenStyle style READ style WRITE setStyle NOTIFY styleChanged REVISION 1)
                 Q_PROPERTY(Qt::PenCapStyle capStyle READ capStyle WRITE setCapStyle NOTIFY capStyleChanged REVISION 1)
                 Q_REVISION(2) void setAxisXTop(QAbstractAxis *axis) { m_axes->setAxisXTop(axis); }
                 Q_REVISION(2) QAbstractAxis *axisYRight() { return m_axes->axisYRight(); }
                 Q_REVISION(2) void setAxisYRight(QAbstractAxis *axis) { m_axes->setAxisYRight(axis); }
+                Q_REVISION(3) QAbstractAxis *axisAngular() { return m_axes->axisX(); }
+                Q_REVISION(3) void setAxisAngular(QAbstractAxis *axis) { m_axes->setAxisX(axis); }
+                Q_REVISION(3) QAbstractAxis *axisRadial() { return m_axes->axisY(); }
+                Q_REVISION(3) void setAxisRadial(QAbstractAxis *axis) { m_axes->setAxisY(axis); }
                 qreal width() const;
                 void setWidth(qreal width);
                 Qt::PenStyle style() const;
                 Q_REVISION(1) void axisYChanged(QAbstractAxis *axis);
                 Q_REVISION(2) void axisXTopChanged(QAbstractAxis *axis);
                 Q_REVISION(2) void axisYRightChanged(QAbstractAxis *axis);
+                Q_REVISION(3) void axisAngularChanged(QAbstractAxis *axis);
+                Q_REVISION(3) void axisRadialChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void widthChanged(qreal width);
                 Q_REVISION(1) void styleChanged(Qt::PenStyle style);
                 Q_REVISION(1) void capStyleChanged(Qt::PenCapStyle capStyle);

plugins/declarative/plugin.cpp +9 0

             #include "declarativecategoryaxis.h"
             #include "qbarcategoryaxis.h"
             #include "declarativechart.h"
+            #include "declarativepolarchart.h"
             #include "declarativexypoint.h"
             #include "declarativelineseries.h"
             #include "declarativesplineseries.h"
             // These should not be needed or at least they are not needed in Qt4.
             Q_DECLARE_METATYPE(DeclarativeChart *)
+            Q_DECLARE_METATYPE(DeclarativePolarChart *)
             Q_DECLARE_METATYPE(DeclarativeMargins *)
             Q_DECLARE_METATYPE(DeclarativeAreaSeries *)
             Q_DECLARE_METATYPE(DeclarativeBarSeries *)
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 2>(uri, 1, 2, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 2>(uri, 1, 2, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 2>(uri, 1, 2, "HorizontalPercentBarSeries");
+                    // QtCommercial.Chart 1.3
+                    qmlRegisterType<DeclarativePolarChart, 1>(uri, 1, 3, "PolarChartView");
+                    qmlRegisterType<DeclarativeSplineSeries, 3>(uri, 1, 3, "SplineSeries");
+                    qmlRegisterType<DeclarativeScatterSeries, 3>(uri, 1, 3, "ScatterSeries");
+                    qmlRegisterType<DeclarativeLineSeries, 3>(uri, 1, 3, "LineSeries");
+                    qmlRegisterType<DeclarativeAreaSeries, 3>(uri, 1, 3, "AreaSeries");
                 }
             };

src/animations/axisanimation.cpp +7 -6

             ****************************************************************************/
             #include "axisanimation_p.h"
-            #include "chartaxis_p.h"
+            #include "chartaxiselement_p.h"
+            #include "qabstractaxis_p.h"
             Q_DECLARE_METATYPE(QVector<qreal>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            AxisAnimation::AxisAnimation(ChartAxis *axis)
+            AxisAnimation::AxisAnimation(ChartAxisElement *axis)
                 : ChartAnimation(axis),
                   m_axis(axis),
                   m_type(DefaultAnimation)
                     oldLayout.resize(newLayout.count());
                     for (int i = 0, j = oldLayout.count() - 1; i < (oldLayout.count() + 1) / 2; ++i, --j) {
-                        oldLayout[i] = m_axis->orientation() == Qt::Horizontal ? rect.left() : rect.bottom();
+                        oldLayout[i] = m_axis->axis()->orientation() == Qt::Horizontal ? rect.left() : rect.bottom();
-                        oldLayout[j] = m_axis->orientation() == Qt::Horizontal ? rect.right() : rect.top();
+                        oldLayout[j] = m_axis->axis()->orientation() == Qt::Horizontal ? rect.right() : rect.top();
                     }
                 }
                 break;
                 case ZoomInAnimation: {
-                    int index = qMin(oldLayout.count() * (m_axis->orientation() == Qt::Horizontal ? m_point.x() : (1 - m_point.y())), newLayout.count() - (qreal)1.0);
+                    int index = qMin(oldLayout.count() * (m_axis->axis()->orientation() == Qt::Horizontal ? m_point.x() : (1 - m_point.y())), newLayout.count() - (qreal)1.0);
                     oldLayout.resize(newLayout.count());
                     for (int i = 0; i < oldLayout.count(); i++)
                     oldLayout.resize(newLayout.count());
                     QRectF rect = m_axis->gridGeometry();
                     for (int i = 0, j = oldLayout.count() - 1; i < oldLayout.count(); ++i, --j)
-                        oldLayout[i] = m_axis->orientation() == Qt::Horizontal ? rect.left() : rect.top();
+                        oldLayout[i] = m_axis->axis()->orientation() == Qt::Horizontal ? rect.left() : rect.top();
                 }
                 break;
                 }

src/animations/axisanimation_p.h +3 -3

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class ChartAxis;
+            class ChartAxisElement;
             class AxisAnimation: public ChartAnimation
             {
             public:
                 enum Animation { DefaultAnimation, ZoomOutAnimation, ZoomInAnimation, MoveForwardAnimation, MoveBackwordAnimation};
-                AxisAnimation(ChartAxis *axis);
+                AxisAnimation(ChartAxisElement *axis);
                 ~AxisAnimation();
                 void setAnimationType(Animation type);
                 void setAnimationPoint(const QPointF &point);
                 QVariant interpolated(const QVariant &from, const QVariant &to, qreal progress) const;
                 void updateCurrentValue(const QVariant &value);
             private:
-                ChartAxis *m_axis;
+                ChartAxisElement *m_axis;
                 Animation m_type;
                 QPointF m_point;
             };

src/areachart/areachartitem.cpp +21 -3

                 path = m_upper->path();
                 if (m_lower) {
+                    // Note: Polarcharts always draw area correctly only when both series have equal width or are
+                    // fully displayed. If one series is partally off-chart, the connecting line between
+                    // the series does not attach to the end of the partially hidden series but to the point
+                    // where it intersects the axis line. The problem is especially noticeable when one of the series
+                    // is entirely off-chart, in which case the connecting line connects two ends of the
+                    // visible series.
+                    // This happens because we get the paths from linechart, which omits off-chart segments.
+                    // To properly fix, linechart would need to provide true full path, in right, left, and the rest
+                    // portions to enable proper clipping. However, combining those to single visually unified area
+                    // would be a nightmare, since they would have to be painted separately.
                     path.connectPath(m_lower->path().toReversed());
                 } else {
                     QPointF first = path.pointAtPercent(0);
                     QPointF last =  path.pointAtPercent(1);
-                    path.lineTo(last.x(), rect.bottom());
+                    if (presenter()->chartType() == QChart::ChartTypeCartesian) {
-                    path.lineTo(first.x(), rect.bottom());
+                        path.lineTo(last.x(), rect.bottom());
+                        path.lineTo(first.x(), rect.bottom());
+                    } else { // polar
+                        path.lineTo(rect.center());
+                    }
                 }
                 path.closeSubpath();
                 prepareGeometryChange();
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(m_brush);
-                painter->setClipRect(QRectF(QPointF(0,0),domain()->size()));
+                QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
+                if (presenter()->chartType() == QChart::ChartTypePolar)
+                    painter->setClipRegion(QRegion(clipRect.toRect(), QRegion::Ellipse));
+                else
+                    painter->setClipRect(clipRect);
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                     painter->setPen(m_pointPen);

src/areachart/areachartitem_p.h +9 -1

             #include "qchartglobal.h"
             #include "linechartitem_p.h"
+            #include "qareaseries.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QAreaSeries;
             class AreaChartItem;
             class AreaChartItem : public ChartItem
                 void updatePath();
                 void setPresenter(ChartPresenter *presenter);
+                QAreaSeries *series() const { return m_series; }
             protected:
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 AreaBoundItem(AreaChartItem *area, QLineSeries *lineSeries,QGraphicsItem* item = 0)
                     : LineChartItem(lineSeries, item), m_item(area)
                 {
+                    // We do not actually want to draw anything from LineChartItem.
+                    // Drawing is done in AreaChartItem only.
+                    setVisible(false);
                 }
                 ~AreaBoundItem() {}
                     // Turn off points drawing from component line chart item, as that
                     // messes up the fill for area series.
                     suppressPoints();
+                    // Component lineseries are not necessarily themselves on the chart,
+                    // so get the chart type for them from area chart.
+                    forceChartType(m_item->series()->chart()->chartType());
                     LineChartItem::updateGeometry();
                     m_item->updatePath();
                 }

src/axis/axis.pri +34 -4

                 $$PWD/logvalueaxis
             SOURCES += \
-                $$PWD/chartaxis.cpp \
+                $$PWD/chartaxiselement.cpp \
+                $$PWD/cartesianchartaxis.cpp \
                 $$PWD/qabstractaxis.cpp \
                 $$PWD/verticalaxis.cpp \
                 $$PWD/horizontalaxis.cpp \
                 $$PWD/logvalueaxis/qlogvalueaxis.cpp
             PRIVATE_HEADERS += \
-                $$PWD/chartaxis_p.h \
+                $$PWD/chartaxiselement_p.h \
+                $$PWD/cartesianchartaxis_p.h \
                 $$PWD/qabstractaxis_p.h \
                 $$PWD/verticalaxis_p.h \
                 $$PWD/horizontalaxis_p.h \
+                $$PWD/linearrowitem_p.h \
                 $$PWD/valueaxis/chartvalueaxisx_p.h \
                 $$PWD/valueaxis/chartvalueaxisy_p.h \
                 $$PWD/valueaxis/qvalueaxis_p.h \
                 $$PWD/categoryaxis/qcategoryaxis.h \
                 $$PWD/logvalueaxis/qlogvalueaxis.h \
+            # polar
+            SOURCES += \
+                $$PWD/polarchartaxis.cpp \
+                $$PWD/polarchartaxisangular.cpp \
+                $$PWD/polarchartaxisradial.cpp \
+                $$PWD/valueaxis/polarchartvalueaxisangular.cpp \
+                $$PWD/valueaxis/polarchartvalueaxisradial.cpp \
+                $$PWD/logvalueaxis/polarchartlogvalueaxisangular.cpp \
+                $$PWD/logvalueaxis/polarchartlogvalueaxisradial.cpp \
+                $$PWD/categoryaxis/polarchartcategoryaxisangular.cpp \
+                $$PWD/categoryaxis/polarchartcategoryaxisradial.cpp
+            PRIVATE_HEADERS += \
+                $$PWD/polarchartaxis_p.h \
+                $$PWD/polarchartaxisangular_p.h \
+                $$PWD/polarchartaxisradial_p.h \
+                $$PWD/valueaxis/polarchartvalueaxisangular_p.h \
+                $$PWD/valueaxis/polarchartvalueaxisradial_p.h \
+                $$PWD/logvalueaxis/polarchartlogvalueaxisangular_p.h \
+                $$PWD/logvalueaxis/polarchartlogvalueaxisradial_p.h \
+                $$PWD/categoryaxis/polarchartcategoryaxisangular_p.h \
+                $$PWD/categoryaxis/polarchartcategoryaxisradial_p.h
             !linux-arm*: {
             INCLUDEPATH += \
                 $$PWD/datetimeaxis
             SOURCES += \
                 $$PWD/datetimeaxis/chartdatetimeaxisx.cpp \
                 $$PWD/datetimeaxis/chartdatetimeaxisy.cpp \
-                $$PWD/datetimeaxis/qdatetimeaxis.cpp
+                $$PWD/datetimeaxis/qdatetimeaxis.cpp \
+                $$PWD/datetimeaxis/polarchartdatetimeaxisangular.cpp \
+                $$PWD/datetimeaxis/polarchartdatetimeaxisradial.cpp
             PRIVATE_HEADERS += \
                 $$PWD/datetimeaxis/chartdatetimeaxisx_p.h \
                 $$PWD/datetimeaxis/chartdatetimeaxisy_p.h \
-                $$PWD/datetimeaxis/qdatetimeaxis_p.h
+                $$PWD/datetimeaxis/qdatetimeaxis_p.h \
+                $$PWD/datetimeaxis/polarchartdatetimeaxisangular_p.h \
+                $$PWD/datetimeaxis/polarchartdatetimeaxisradial_p.h
             PUBLIC_HEADERS += \
                 $$PWD/datetimeaxis/qdatetimeaxis.h

src/axis/barcategoryaxis/chartbarcategoryaxisx.cpp +3 -3

             #include "chartbarcategoryaxisx_p.h"
             #include "chartpresenter_p.h"
             #include "qbarcategoryaxis_p.h"
-            #include "chartlayout_p.h"
+            #include "abstractchartlayout_p.h"
             #include <QFontMetrics>
             #include <QDebug>
             #include <qmath.h>
             void ChartBarCategoryAxisX::updateGeometry()
             {
-                const QVector<qreal>& layout = ChartAxis::layout();
+                const QVector<qreal>& layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createCategoryLabels(layout));
             {
                 Q_UNUSED(constraint)
-                QFontMetrics fn(font());
+                QFontMetrics fn(axis()->labelsFont());
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
                 QStringList ticksList = m_categoriesAxis->categories();

src/axis/barcategoryaxis/chartbarcategoryaxisy.cpp +3 -3

             #include "chartbarcategoryaxisy_p.h"
             #include "chartpresenter_p.h"
             #include "qbarcategoryaxis_p.h"
-            #include "chartlayout_p.h"
+            #include "abstractchartlayout_p.h"
             #include <qmath.h>
             #include <QFontMetrics>
             #include <QDebug>
             void ChartBarCategoryAxisY::updateGeometry()
             {
-                const QVector<qreal>& layout = ChartAxis::layout();
+                const QVector<qreal>& layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createCategoryLabels(layout));
             {
                 Q_UNUSED(constraint)
-                QFontMetrics fn(font());
+                QFontMetrics fn(axis()->labelsFont());
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
                 QStringList ticksList = m_categoriesAxis->categories();

src/axis/barcategoryaxis/qbarcategoryaxis.cpp +2 -2

             /*!
               \fn void QBarCategoryAxis::categoriesChanged()
-              Axis emits signal when the categories of the axis has changed.
+              Axis emits signal when the categories of the axis have changed.
             */
             /*!
             void QBarCategoryAxisPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QBarCategoryAxis);
-                ChartAxis* axis(0);
+                ChartAxisElement* axis(0);
                 if (orientation() == Qt::Vertical)
                     axis = new ChartBarCategoryAxisY(q,parent);
                 if (orientation() == Qt::Horizontal)

src/axis/categoryaxis/chartcategoryaxisx.cpp +11 -6

             #include "qcategoryaxis.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
+            #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
                 : HorizontalAxis(axis, item, true),
                   m_axis(axis)
             {
+                QObject::connect(axis, SIGNAL(categoriesChanged()), this, SLOT(handleCategoriesChanged()));
             }
             ChartCategoryAxisX::~ChartCategoryAxisX()
                 HorizontalAxis::updateGeometry();
             }
-            void ChartCategoryAxisX::handleAxisUpdated()
-                updateGeometry();
             QSizeF ChartCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
-                QFontMetrics fn(font());
+                QFontMetrics fn(axis()->labelsFont());
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
                 QStringList ticksList = m_axis->categoriesLabels();
                 return sh;
             }
+            void ChartCategoryAxisX::handleCategoriesChanged()
+            {
+                QGraphicsLayoutItem::updateGeometry();
+                presenter()->layout()->invalidate();
+            }
+            #include "moc_chartcategoryaxisx_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoryaxis/chartcategoryaxisx_p.h +4 -4

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QCategoryAxis;
-            class ChartPresenter;
             class ChartCategoryAxisX : public HorizontalAxis
             {
+                Q_OBJECT
             public:
                 ChartCategoryAxisX(QCategoryAxis *axis, QGraphicsItem* item = 0);
                 ~ChartCategoryAxisX();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
+            public Q_SLOTS:
+                void handleCategoriesChanged();
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();
-            public Q_SLOTS:
-                void handleAxisUpdated();
             private:
                 QCategoryAxis *m_axis;
             };

src/axis/categoryaxis/chartcategoryaxisy.cpp +11 -6

             #include "qcategoryaxis.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
+            #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
                 : VerticalAxis(axis, item, true),
                   m_axis(axis)
             {
+                QObject::connect(axis, SIGNAL(categoriesChanged()), this, SLOT(handleCategoriesChanged()));
             }
             ChartCategoryAxisY::~ChartCategoryAxisY()
                 VerticalAxis::updateGeometry();
             }
-            void ChartCategoryAxisY::handleAxisUpdated()
-                updateGeometry();
             QSizeF ChartCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
-                QFontMetrics fn(font());
+                QFontMetrics fn(axis()->labelsFont());
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
                 QStringList ticksList = m_axis->categoriesLabels();
                 return sh;
             }
+            void ChartCategoryAxisY::handleCategoriesChanged()
+            {
+                QGraphicsLayoutItem::updateGeometry();
+                presenter()->layout()->invalidate();
+            }
+            #include "moc_chartcategoryaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoryaxis/chartcategoryaxisy_p.h +4 -4

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QCategoryAxis;
-            class ChartPresenter;
             class ChartCategoryAxisY : public VerticalAxis
             {
+                Q_OBJECT
             public:
                 ChartCategoryAxisY(QCategoryAxis *axis, QGraphicsItem* item = 0);
                 ~ChartCategoryAxisY();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
+            public Q_SLOTS:
+                void handleCategoriesChanged();
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();
-            public Q_SLOTS:
-                void handleAxisUpdated();
             private:
                 QCategoryAxis *m_axis;
             };

src/axis/categoryaxis/qcategoryaxis.cpp +31 -9

             #include "qcategoryaxis_p.h"
             #include "chartcategoryaxisx_p.h"
             #include "chartcategoryaxisy_p.h"
+            #include "polarchartcategoryaxisangular_p.h"
+            #include "polarchartcategoryaxisradial_p.h"
             #include "qchart.h"
             #include <qmath.h>
             #include <QDebug>
             */
             /*!
+              \fn void QCategoryAxis::categoriesChanged()
+              Axis emits signal when the categories of the axis have changed.
+            */
+            /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QCategoryAxis::QCategoryAxis(QObject *parent):
                         Range range(d->m_categoryMinimum, categoryEndValue);
                         d->m_categoriesMap.insert(categoryLabel, range);
                         d->m_categories.append(categoryLabel);
+                        emit categoriesChanged();
                     } else if (categoryEndValue > endValue(d->m_categories.last())) {
                         Range previousRange = d->m_categoriesMap.value(d->m_categories.last());
                         d->m_categoriesMap.insert(categoryLabel, Range(previousRange.second, categoryEndValue));
                         d->m_categories.append(categoryLabel);
+                        emit categoriesChanged();
                     }
                 }
             }
                 Q_D(QCategoryAxis);
                 if (d->m_categories.isEmpty()) {
                     d->m_categoryMinimum = min;
+                    emit categoriesChanged();
                 } else {
                     Range range = d->m_categoriesMap.value(d->m_categories.first());
-                    if (min < range.second)
+                    if (min < range.second) {
                         d->m_categoriesMap.insert(d->m_categories.first(), Range(min, range.second));
+                        emit categoriesChanged();
+                    }
                 }
             }
                             d->m_categoriesMap.insert(label, range);
                         }
                     }
-                    //TODO:: d->emitUpdated();
+                    emit categoriesChanged();
                 }
             }
                     Range range = d->m_categoriesMap.value(oldLabel);
                     d->m_categoriesMap.remove(oldLabel);
                     d->m_categoriesMap.insert(newLabel, range);
-                    //TODO:: d->emitUpdated();
+                    emit categoriesChanged();
                 }
             }
                 return m_categories.count() + 1;
             }
-            void QCategoryAxisPrivate::initializeGraphics(QGraphicsItem* parent)
+            void QCategoryAxisPrivate::initializeGraphics(QGraphicsItem *parent)
             {
                 Q_Q(QCategoryAxis);
-                ChartAxis* axis(0);
+                ChartAxisElement *axis(0);
-                if (orientation() == Qt::Vertical)
+                if (m_chart->chartType() == QChart::ChartTypeCartesian) {
-                    axis = new ChartCategoryAxisY(q,parent);
+                    if (orientation() == Qt::Vertical)
-                else if(orientation() == Qt::Horizontal)
+                        axis = new ChartCategoryAxisY(q,parent);
-                    axis = new ChartCategoryAxisX(q,parent);
+                    else if (orientation() == Qt::Horizontal)
+                        axis = new ChartCategoryAxisX(q,parent);
+                }
+                if (m_chart->chartType() == QChart::ChartTypePolar) {
+                    if (orientation() == Qt::Vertical)
+                        axis = new PolarChartCategoryAxisRadial(q, parent);
+                    if (orientation() == Qt::Horizontal)
+                        axis = new PolarChartCategoryAxisAngular(q, parent);
+                }
                 m_item.reset(axis);
                 QAbstractAxisPrivate::initializeGraphics(parent);

src/axis/categoryaxis/qcategoryaxis.h +3 0

                 QStringList categoriesLabels();
                 int count() const;
+            Q_SIGNALS:
+                void categoriesChanged();
             private:
                 Q_DECLARE_PRIVATE(QCategoryAxis)
                 Q_DISABLE_COPY(QCategoryAxis)

src/axis/categoryaxis/qcategoryaxis_p.h 0 -3

                 void initializeGraphics(QGraphicsItem* parent);
                 int ticksCount() const;
-            Q_SIGNALS:
-                void changed(qreal min, qreal max, int tickCount, bool niceNumbers);
             private:
                 QMap<QString , Range> m_categoriesMap;
                 QStringList m_categories;

src/axis/chartaxiselement_p.h ~~src/axis/chartaxis_p.h~~ renamed +64 -114

@@ -27,8 +27,8
27	//	27	//
28	// We mean it.	28	// We mean it.
29		29
30	#ifndef CHARTAXIS_H	30	#ifndef CHARTAXISELEMENT_H
31	#define CHARTAXIS_H	31	#define CHARTAXISELEMENT_H
32		32
33	#include "qchartglobal.h"	33	#include "qchartglobal.h"
34	#include "chartelement_p.h"	34	#include "chartelement_p.h"
@@ -39,163 +39,113
39		39
40	QTCOMMERCIALCHART_BEGIN_NAMESPACE	40	QTCOMMERCIALCHART_BEGIN_NAMESPACE
41		41
42	class QAbstractAxis;
43	class ChartPresenter;	42	class ChartPresenter;
		43	class QAbstractAxis;
44		44
45	class ChartAxis : public ChartElement, public QGraphicsLayoutItem	45	class ChartAxisElement : public ChartElement, public QGraphicsLayoutItem
46	{	46	{
47	Q_OBJECT	47	Q_OBJECT
48	Q_INTERFACES(QGraphicsLayoutItem)
49	public:	48	public:
		49	ChartAxisElement(QAbstractAxis axis, QGraphicsItem item, bool intervalAxis = false);
		50	~ChartAxisElement();
		51
		52	virtual QRectF gridGeometry() const = 0;
		53	virtual void setGeometry(const QRectF &axis, const QRectF &grid) = 0;
		54	virtual bool isEmpty() = 0;
		55
		56	void setAnimation(AxisAnimation *animation) { m_animation = animation; }
		57	AxisAnimation *animation() const { return m_animation; }
		58
		59	QAbstractAxis *axis() const { return m_axis; }
		60	void setLayout(QVector<qreal> &layout) { m_layout = layout; }
		61	QVector<qreal> &layout() { return m_layout; } // Modifiable reference
		62	int labelPadding() const { return 5; }
		63	int titlePadding() const { return 3; }
		64	void setLabels(const QStringList &labels) { m_labelsList = labels; }
		65	QStringList labels() const { return m_labelsList; }
50		66
51	ChartAxis(QAbstractAxis axis, QGraphicsItem item = 0, bool intervalAxis = false);	67	qreal min() const;
52	~ChartAxis();	68	qreal max() const;
53
54	QAbstractAxis* axis() const { return m_axis; }
55
56	void setLabelPadding(int padding);
57	int labelPadding() const { return m_labelPadding;};
58
59	void setTitlePadding(int padding);
60	int titlePadding() const { return m_titlePadding;};
61
62	QFont titleFont() const;
63	QString titleText() const;
64
65	void setLayout(QVector<qreal> &layout);
66	QVector<qreal> layout() const { return m_layoutVector; }
67
68	void setAnimation(AxisAnimation *animation);
69	ChartAnimation *animation() const { return m_animation; };
70
71	Qt::Orientation orientation() const;
72	Qt::Alignment alignment() const;
73		69
74	void setGeometry(const QRectF &axis, const QRectF &grid);
75	QRectF axisGeometry() const { return m_axisRect; }	70	QRectF axisGeometry() const { return m_axisRect; }
76	QRectF gridGeometry() const { return m_gridRect; }	71	void setAxisGeometry(const QRectF &axisGeometry) { m_axisRect = axisGeometry; }
77		72
78	void setLabels(const QStringList &labels);	73	QRect labelBoundingRect(const QFontMetrics &fn, const QString &label) const;
79	QStringList labels() const { return m_labelsList; }	74
		75	void axisSelected();
80		76
81	//this flag indicates that axis is used to show intervals it means labels are in between ticks	77	//this flag indicates that axis is used to show intervals it means labels are in between ticks
82	bool intervalAxis() const { return m_intervalAxis; }	78	bool intervalAxis() const { return m_intervalAxis; }
83		79
84	virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;	80	static QStringList createValueLabels(qreal max, qreal min, int ticks, const QString &format);
85		81	static QStringList createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString &format);
		82	static QStringList createDateTimeLabels(qreal max, qreal min, int ticks, const QString &format);
86		83
87	QRectF boundingRect() const{	84	// from QGraphicsLayoutItem
		85	QRectF boundingRect() const
		86	{
88	return QRectF();	87	return QRectF();
89	}	88	}
90		89
		90	// from QGraphicsLayoutItem
91	void paint(QPainter, const QStyleOptionGraphicsItem, QWidget*)	91	void paint(QPainter, const QStyleOptionGraphicsItem, QWidget*)
92	{	92	{
93
94	}	93	}
95		94
96	//helpers
97	static QStringList createValueLabels(qreal max, qreal min, int ticks, const QString &format);
98	static QStringList createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString& format);
99	static QStringList createDateTimeLabels(qreal max, qreal min, int ticks, const QString &format);
100
101	protected:	95	protected:
102	void setGeometry(const QRectF &size) { Q_UNUSED(size);};
103	virtual void updateGeometry() = 0;
104	virtual QVector<qreal> calculateLayout() const = 0;	96	virtual QVector<qreal> calculateLayout() const = 0;
		97	virtual void updateLayout(QVector<qreal> &layout) = 0;
		98
		99	QList<QGraphicsItem *> gridItems() { return m_grid->childItems(); }
		100	QList<QGraphicsItem *> labelItems() { return m_labels->childItems(); }
		101	QList<QGraphicsItem *> shadeItems() { return m_shades->childItems(); }
		102	QList<QGraphicsItem *> arrowItems() { return m_arrow->childItems(); }
		103	QGraphicsSimpleTextItem *titleItem() const { return m_title.data(); }
		104	QGraphicsItemGroup *gridGroup() { return m_grid.data(); }
		105	QGraphicsItemGroup *labelGroup() { return m_labels.data(); }
		106	QGraphicsItemGroup *shadeGroup() { return m_shades.data(); }
		107	QGraphicsItemGroup *arrowGroup() { return m_arrow.data(); }
105		108
106	QList<QGraphicsItem *> lineItems() { return m_grid->childItems(); };
107	QList<QGraphicsItem *> labelItems() { return m_labels->childItems();};
108	QList<QGraphicsItem *> shadeItems() { return m_shades->childItems();};
109	QList<QGraphicsItem *> arrowItems() { return m_arrow->childItems();};
110	QGraphicsSimpleTextItem* titleItem() const { return m_title.data();}
111
112	QFont font() const;
113	qreal min() const;
114	qreal max() const;
115	QRect labelBoundingRect(const QFontMetrics &fn, const QString &label) const;
116
117	//handlers
118	public Q_SLOTS:	109	public Q_SLOTS:
119	void handleVisibleChanged(bool visible);	110	void handleVisibleChanged(bool visible);
120	void handleArrowVisibleChanged(bool visible);	111	void handleArrowVisibleChanged(bool visible);
121	void handleGridVisibleChanged(bool visible);	112	void handleGridVisibleChanged(bool visible);
122	void handleLabelsVisibleChanged(bool visible);	113	void handleLabelsVisibleChanged(bool visible);
123	void handleShadesVisibleChanged(bool visible);	114	void handleShadesVisibleChanged(bool visible);
124	void handleLabelsAngleChanged(int angle);	115	void handleLabelsAngleChanged(int angle);
125	void handleShadesBrushChanged(const QBrush &brush);	116	virtual void handleShadesBrushChanged(const QBrush &brush) = 0;
126	void handleShadesPenChanged(const QPen &pen);	117	virtual void handleShadesPenChanged(const QPen &pen) = 0;
127	void handleArrowPenChanged(const QPen &pen);	118	virtual void handleArrowPenChanged(const QPen &pen) = 0;
128	void handleGridPenChanged(const QPen &pen);	119	virtual void handleGridPenChanged(const QPen &pen) = 0;
129	void handleLabelsPenChanged(const QPen &pen);	120	void handleLabelsPenChanged(const QPen &pen);
130	void handleLabelsBrushChanged(const QBrush &brush);	121	void handleLabelsBrushChanged(const QBrush &brush);
131	void handleLabelsFontChanged(const QFont &font);	122	void handleLabelsFontChanged(const QFont &font);
132	void handleTitlePenChanged(const QPen &pen);	123	void handleTitlePenChanged(const QPen &pen);
133	void handleTitleBrushChanged(const QBrush &brush);	124	void handleTitleBrushChanged(const QBrush &brush);
134	void handleTitleFontChanged(const QFont &font);	125	void handleTitleFontChanged(const QFont &font);
135	void handleTitleTextChanged(const QString &title);	126	void handleTitleTextChanged(const QString &title);
136	void handleTitleVisibleChanged(bool visible);	127	void handleTitleVisibleChanged(bool visible);
137	void handleRangeChanged(qreal min , qreal max);	128	void handleRangeChanged(qreal min, qreal max);
138		129
139	Q_SIGNALS:	130	Q_SIGNALS:
140	void clicked();	131	void clicked();
141		132
142	private:	133	private:
143	inline bool isEmpty();
144	void createItems(int count);
145	void deleteItems(int count);
146	void updateLayout(QVector<qreal> &layout);
147	void axisSelected();
148	void connectSlots();	134	void connectSlots();
149		135
150	private:
151	QAbstractAxis *m_axis;	136	QAbstractAxis *m_axis;
152	int m_labelsAngle;	137	AxisAnimation *m_animation;
		138	QVector<qreal> m_layout;
		139	QStringList m_labelsList;
153	QRectF m_axisRect;	140	QRectF m_axisRect;
154	QRectF m_gridRect;
155	QScopedPointer<QGraphicsItemGroup> m_grid;	141	QScopedPointer<QGraphicsItemGroup> m_grid;
156	QScopedPointer<QGraphicsItemGroup> m_arrow;	142	QScopedPointer<QGraphicsItemGroup> m_arrow;
157	QScopedPointer<QGraphicsItemGroup> m_shades;	143	QScopedPointer<QGraphicsItemGroup> m_shades;
158	QScopedPointer<QGraphicsItemGroup> m_labels;	144	QScopedPointer<QGraphicsItemGroup> m_labels;
159	QScopedPointer<QGraphicsSimpleTextItem> m_title;	145	QScopedPointer<QGraphicsSimpleTextItem> m_title;
160	QVector<qreal> m_layoutVector;
161	AxisAnimation *m_animation;
162	int m_labelPadding;
163	QStringList m_labelsList;
164	bool m_intervalAxis;	146	bool m_intervalAxis;
165	int m_titlePadding;
166
167	friend class AxisAnimation;
168	friend class ArrowItem;
169
170	};
171
172	class ArrowItem: public QGraphicsLineItem
173	{
174
175	public:
176	explicit ArrowItem(ChartAxis axis, QGraphicsItem parent = 0) : QGraphicsLineItem(parent), m_axis(axis) {}
177
178	protected:
179	void mousePressEvent(QGraphicsSceneMouseEvent *event) {
180	Q_UNUSED(event)
181	m_axis->axisSelected();
182	}
183
184	QRectF boundingRect() const {
185	return shape().boundingRect();
186	}
187
188	QPainterPath shape() const {
189	QPainterPath path = QGraphicsLineItem::shape();
190	QRectF rect = path.boundingRect();
191	path.addRect(rect.adjusted(0, 0, m_axis->orientation() != Qt::Horizontal ? 8 : 0, m_axis->orientation() != Qt::Vertical ? 8 : 0));
192	return path;
193	}
194
195	private:
196	ChartAxis *m_axis;
197	};	147	};
198		148
199	QTCOMMERCIALCHART_END_NAMESPACE	149	QTCOMMERCIALCHART_END_NAMESPACE
200		150
201	#endif /* CHARTAXI_H */	151	#endif /* CHARTAXISELEMENT_H */

src/axis/datetimeaxis/chartdatetimeaxisx.cpp +13 -11

             #include "chartdatetimeaxisx_p.h"
             #include "chartpresenter_p.h"
             #include "qdatetimeaxis.h"
-            #include "chartlayout_p.h"
+            #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <QDateTime>
             #include <QFontMetrics>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartDateTimeAxisX::ChartDateTimeAxisX(QDateTimeAxis *axis, QGraphicsItem* item)
+            ChartDateTimeAxisX::ChartDateTimeAxisX(QDateTimeAxis *axis, QGraphicsItem *item)
                 : HorizontalAxis(axis, item),
                   m_axis(axis)
             {
-                QObject::connect(m_axis,SIGNAL(tickCountChanged(int)),this, SLOT(handleTickCountChanged(int)));
+                QObject::connect(m_axis, SIGNAL(tickCountChanged(int)), this, SLOT(handleTickCountChanged(int)));
-                QObject::connect(m_axis,SIGNAL(formatChanged(QString)),this, SLOT(handleFormatChanged(QString)));
+                QObject::connect(m_axis, SIGNAL(formatChanged(QString)), this, SLOT(handleFormatChanged(QString)));
             }
             ChartDateTimeAxisX::~ChartDateTimeAxisX()
             void ChartDateTimeAxisX::updateGeometry()
             {
-                const QVector<qreal>& layout = ChartAxis::layout();
+                const QVector<qreal>& layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
-                setLabels(createDateTimeLabels(min(),max(), layout.size(),m_axis->format()));
+                setLabels(createDateTimeLabels(min(), max(), layout.size(), m_axis->format()));
                 HorizontalAxis::updateGeometry();
             }
             {
                 Q_UNUSED(tick)
                 QGraphicsLayoutItem::updateGeometry();
-                if(presenter()) presenter()->layout()->invalidate();
+                if (presenter())
+                    presenter()->layout()->invalidate();
             }
             void ChartDateTimeAxisX::handleFormatChanged(const QString &format)
             {
                 Q_UNUSED(format);
                 QGraphicsLayoutItem::updateGeometry();
-                if(presenter()) presenter()->layout()->invalidate();
+                if (presenter())
+                    presenter()->layout()->invalidate();
             }
             QSizeF ChartDateTimeAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
-                QFontMetrics fn(font());
+                QFontMetrics fn(axis()->labelsFont());
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
-                QStringList ticksList = createDateTimeLabels(min(),max(),m_axis->tickCount(),m_axis->format());
+                QStringList ticksList = createDateTimeLabels(min(), max(), m_axis->tickCount(), m_axis->format());
                 // Width of horizontal axis sizeHint indicates the maximum distance labels can extend past
                 // first and last ticks. Base width is irrelevant.
                 qreal width = 0;
                     return sh;
                 switch (which) {
-                case Qt::MinimumSize:{
+                case Qt::MinimumSize: {
                     QRectF boundingRect = labelBoundingRect(fn, "...");
                     width = boundingRect.width() / 2.0;
                     height = boundingRect.height() + labelPadding();

src/axis/datetimeaxis/chartdatetimeaxisx_p.h 0 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QDateTimeAxis;
-            class ChartPresenter;
             class ChartDateTimeAxisX : public HorizontalAxis
             {

src/axis/datetimeaxis/chartdatetimeaxisy.cpp +12 -10

             #include "chartdatetimeaxisy_p.h"
             #include "chartpresenter_p.h"
             #include "qdatetimeaxis.h"
-            #include "chartlayout_p.h"
+            #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <QDateTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartDateTimeAxisY::ChartDateTimeAxisY(QDateTimeAxis *axis, QGraphicsItem* item)
+            ChartDateTimeAxisY::ChartDateTimeAxisY(QDateTimeAxis *axis, QGraphicsItem *item)
                 : VerticalAxis(axis, item),
                   m_axis(axis)
             {
-                QObject::connect(m_axis,SIGNAL(tickCountChanged(int)),this, SLOT(handleTickCountChanged(int)));
+                QObject::connect(m_axis, SIGNAL(tickCountChanged(int)), this, SLOT(handleTickCountChanged(int)));
-                QObject::connect(m_axis,SIGNAL(formatChanged(QString)),this, SLOT(handleFormatChanged(QString)));
+                QObject::connect(m_axis, SIGNAL(formatChanged(QString)), this, SLOT(handleFormatChanged(QString)));
             }
             ChartDateTimeAxisY::~ChartDateTimeAxisY()
             void ChartDateTimeAxisY::updateGeometry()
             {
-                const QVector<qreal> &layout = ChartAxis::layout();
+                const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
-                setLabels(createDateTimeLabels(min(),max(), layout.size(),m_axis->format()));
+                setLabels(createDateTimeLabels(min(), max(), layout.size(), m_axis->format()));
                 VerticalAxis::updateGeometry();
             }
             {
                 Q_UNUSED(tick)
                 QGraphicsLayoutItem::updateGeometry();
-                if(presenter()) presenter()->layout()->invalidate();
+                if (presenter())
+                    presenter()->layout()->invalidate();
             }
             void ChartDateTimeAxisY::handleFormatChanged(const QString &format)
             {
                 Q_UNUSED(format);
                 QGraphicsLayoutItem::updateGeometry();
-                if(presenter()) presenter()->layout()->invalidate();
+                if (presenter())
+                    presenter()->layout()->invalidate();
             }
             QSizeF ChartDateTimeAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
-                QFontMetrics fn(font());
+                QFontMetrics fn(axis()->labelsFont());
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
-                QStringList ticksList = createDateTimeLabels(min(),max(),m_axis->tickCount(),m_axis->format());
+                QStringList ticksList = createDateTimeLabels(min(), max(), m_axis->tickCount(), m_axis->format());
                 qreal width = 0;
                 // Height of vertical axis sizeHint indicates the maximum distance labels can extend past
                 // first and last ticks. Base height is irrelevant.

src/axis/datetimeaxis/chartdatetimeaxisy_p.h 0 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QDateTimeAxis;
-            class ChartPresenter;
             class ChartDateTimeAxisY : public VerticalAxis
             {

src/axis/datetimeaxis/qdatetimeaxis.cpp +16 -5

             #include "qdatetimeaxis_p.h"
             #include "chartdatetimeaxisx_p.h"
             #include "chartdatetimeaxisy_p.h"
+            #include "polarchartdatetimeaxisangular_p.h"
+            #include "polarchartdatetimeaxisradial_p.h"
             #include "abstractdomain_p.h"
             #include "qchart.h"
             #include <float.h>
             void QDateTimeAxisPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QDateTimeAxis);
-                ChartAxis* axis(0);
+                ChartAxisElement *axis(0);
-                if (orientation() == Qt::Vertical)
+                if (m_chart->chartType() == QChart::ChartTypeCartesian) {
-                    axis = new ChartDateTimeAxisY(q,parent);
+                    if (orientation() == Qt::Vertical)
-                if (orientation() == Qt::Horizontal)
+                        axis = new ChartDateTimeAxisY(q,parent);
-                    axis = new ChartDateTimeAxisX(q,parent);
+                    if (orientation() == Qt::Horizontal)
+                        axis = new ChartDateTimeAxisX(q,parent);
+                }
+                if (m_chart->chartType() == QChart::ChartTypePolar) {
+                    if (orientation() == Qt::Vertical)
+                        axis = new PolarChartDateTimeAxisRadial(q, parent);
+                    if (orientation() == Qt::Horizontal)
+                        axis = new PolarChartDateTimeAxisAngular(q, parent);
+                }
                 m_item.reset(axis);
                 QAbstractAxisPrivate::initializeGraphics(parent);

src/axis/horizontalaxis.cpp +21 -21

             ****************************************************************************/
             #include "horizontalaxis_p.h"
-            #include "qabstractaxis.h"
+            #include "qabstractaxis_p.h"
             #include <QFontMetrics>
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            HorizontalAxis::HorizontalAxis(QAbstractAxis *axis, QGraphicsItem* item , bool intervalAxis)
+            HorizontalAxis::HorizontalAxis(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
-                : ChartAxis(axis, item, intervalAxis)
+                : CartesianChartAxis(axis, item, intervalAxis)
             {
             }
             void HorizontalAxis::updateGeometry()
             {
-                const QVector<qreal>& layout = ChartAxis::layout();
+                const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 QStringList labelList = labels();
-                QList<QGraphicsItem *> lines = lineItems();
+                QList<QGraphicsItem *> lines = gridItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
-                QList<QGraphicsItem *> axis = arrowItems();
+                QList<QGraphicsItem *> arrow = arrowItems();
-                QGraphicsSimpleTextItem* title = titleItem();
+                QGraphicsSimpleTextItem *title = titleItem();
                 Q_ASSERT(labels.size() == labelList.size());
                 Q_ASSERT(layout.size() == labelList.size());
                 const QRectF &gridRect = gridGeometry();
                 //arrow
-                QGraphicsLineItem *arrowItem = static_cast<QGraphicsLineItem *>(axis.at(0));
+                QGraphicsLineItem *arrowItem = static_cast<QGraphicsLineItem *>(arrow.at(0));
-                if (alignment() == Qt::AlignTop)
+                if (axis()->alignment() == Qt::AlignTop)
                     arrowItem->setLine(gridRect.left(), axisRect.bottom(), gridRect.right(), axisRect.bottom());
-                else if (alignment() == Qt::AlignBottom)
+                else if (axis()->alignment() == Qt::AlignBottom)
                     arrowItem->setLine(gridRect.left(), axisRect.top(), gridRect.right(), axisRect.top());
                 qreal width = 0;
-                QFontMetrics fn(font());
+                QFontMetrics fn(axis()->labelsFont());
                 //title
                 int titlePad = 0;
                 QRectF titleBoundingRect;
-                if (!titleText().isEmpty() && titleItem()->isVisible()) {
+                QString titleText = axis()->titleText();
+                if (!titleText.isEmpty() && titleItem()->isVisible()) {
                     QFontMetrics fn(title->font());
                     int size(0);
                     size = gridRect.width();
-                    QString titleText = this->titleText();
                     if (fn.boundingRect(titleText).width() > size) {
                         QString string = titleText + "...";
                     titleBoundingRect = title->boundingRect();
                     QPointF center = gridRect.center() - titleBoundingRect.center();
-                    if (alignment() == Qt::AlignTop) {
+                    if (axis()->alignment() == Qt::AlignTop) {
                         title->setPos(center.x(), axisRect.top() + titlePad);
-                    } else  if (alignment() == Qt::AlignBottom) {
+                    } else  if (axis()->alignment() == Qt::AlignBottom) {
                         title->setPos(center.x(), axisRect.bottom() - titleBoundingRect.height() - titlePad);
                     }
                 }
                     //items
                     QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem*>(lines.at(i));
-                    QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1));
+                    QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem*>(arrow.at(i + 1));
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
                     //grid line
                     int heightDiff = rect.height() - boundingRect.height();
                     //ticks and label position
-                    if (alignment() == Qt::AlignTop) {
+                    if (axis()->alignment() == Qt::AlignTop) {
                         labelItem->setPos(layout[i] - center.x(), axisRect.bottom() - rect.height() + (heightDiff / 2) - labelPadding());
                         tickItem->setLine(layout[i], axisRect.bottom(), layout[i], axisRect.bottom() - labelPadding());
-                    } else if (alignment() == Qt::AlignBottom) {
+                    } else if (axis()->alignment() == Qt::AlignBottom) {
                         labelItem->setPos(layout[i] - center.x(), axisRect.top() - (heightDiff / 2) + labelPadding());
                         tickItem->setLine(layout[i], axisRect.top(), layout[i], axisRect.top() + labelPadding());
                     }
                     if (x < gridRect.left() || x > gridRect.right()) {
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
-                    }else{
+                    } else {
                         gridItem->setVisible(true);
                         tickItem->setVisible(true);
                     }
             QSizeF HorizontalAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
-                QFontMetrics fn(titleFont());
+                QFontMetrics fn(axis()->titleFont());
                 QSizeF sh(0,0);
-                if (titleText().isEmpty() || !titleItem()->isVisible())
+                if (axis()->titleText().isEmpty() || !titleItem()->isVisible())
                     return sh;
                 switch (which) {

src/axis/horizontalaxis_p.h +3 -3

             #ifndef HORIZONTALAXIS_P_H_
             #define HORIZONTALAXIS_P_H_
-            #include "chartaxis_p.h"
+            #include "cartesianchartaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class HorizontalAxis : public ChartAxis
+            class HorizontalAxis : public CartesianChartAxis
             {
             public:
-                HorizontalAxis(QAbstractAxis *axis, QGraphicsItem* item = 0, bool intervalAxis = false);
+                HorizontalAxis(QAbstractAxis *axis, QGraphicsItem *item = 0, bool intervalAxis = false);
                 ~HorizontalAxis();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
             protected:

src/axis/logvalueaxis/chartlogvalueaxisx.cpp +7 -7

             #include "chartlogvalueaxisx_p.h"
             #include "chartpresenter_p.h"
             #include "qlogvalueaxis.h"
-            #include "chartlayout_p.h"
+            #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartLogValueAxisX::ChartLogValueAxisX(QLogValueAxis *axis, QGraphicsItem* item)
+            ChartLogValueAxisX::ChartLogValueAxisX(QLogValueAxis *axis, QGraphicsItem *item)
                 : HorizontalAxis(axis, item),
                   m_axis(axis)
             {
-                QObject::connect(m_axis,SIGNAL(baseChanged(qreal)),this, SLOT(handleBaseChanged(qreal)));
+                QObject::connect(m_axis, SIGNAL(baseChanged(qreal)), this, SLOT(handleBaseChanged(qreal)));
-                QObject::connect(m_axis,SIGNAL(labelFormatChanged(QString)),this, SLOT(handleLabelFormatChanged(QString)));
+                QObject::connect(m_axis, SIGNAL(labelFormatChanged(QString)), this, SLOT(handleLabelFormatChanged(QString)));
             }
             ChartLogValueAxisX::~ChartLogValueAxisX()
                 const QRectF &gridRect = gridGeometry();
                 const qreal deltaX = gridRect.width() / qAbs(logMax - logMin);
                 for (int i = 0; i < tickCount; ++i)
-                    points[i] = (ceilEdge + i) * deltaX - leftEdge * deltaX + gridRect.left();
+                    points[i] = (ceilEdge + qreal(i)) * deltaX - leftEdge * deltaX + gridRect.left();
                 return points;
             }
             void ChartLogValueAxisX::updateGeometry()
             {
-                const QVector<qreal>& layout = ChartAxis::layout();
+                const QVector<qreal>& layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), layout.size(), m_axis->labelFormat()));
             {
                 Q_UNUSED(constraint)
-                QFontMetrics fn(font());
+                QFontMetrics fn(axis()->labelsFont());
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);

src/axis/logvalueaxis/chartlogvalueaxisx_p.h +1 -3

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLogValueAxis;
-            class ChartPresenter;
             class ChartLogValueAxisX : public HorizontalAxis
             {
                 Q_OBJECT
             public:
-                ChartLogValueAxisX(QLogValueAxis *axis, QGraphicsItem* item);
+                ChartLogValueAxisX(QLogValueAxis *axis, QGraphicsItem *item);
                 ~ChartLogValueAxisX();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
-                void handleAxisUpdated();
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();

src/axis/logvalueaxis/chartlogvalueaxisy.cpp +7 -7

             #include "chartlogvalueaxisy_p.h"
             #include "chartpresenter_p.h"
             #include "qlogvalueaxis.h"
-            #include "chartlayout_p.h"
+            #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartLogValueAxisY::ChartLogValueAxisY(QLogValueAxis *axis, QGraphicsItem* item)
+            ChartLogValueAxisY::ChartLogValueAxisY(QLogValueAxis *axis, QGraphicsItem *item)
                 : VerticalAxis(axis, item),
                   m_axis(axis)
             {
-                QObject::connect(m_axis, SIGNAL(baseChanged(qreal)),this, SLOT(handleBaseChanged(qreal)));
+                QObject::connect(m_axis, SIGNAL(baseChanged(qreal)), this, SLOT(handleBaseChanged(qreal)));
-                QObject::connect(m_axis,SIGNAL(labelFormatChanged(QString)),this, SLOT(handleLabelFormatChanged(QString)));
+                QObject::connect(m_axis, SIGNAL(labelFormatChanged(QString)), this, SLOT(handleLabelFormatChanged(QString)));
             }
             ChartLogValueAxisY::~ChartLogValueAxisY()
                 const QRectF &gridRect = gridGeometry();
                 const qreal deltaY = gridRect.height() / qAbs(logMax - logMin);
                 for (int i = 0; i < tickCount; ++i)
-                    points[i] = (ceilEdge + i) * -deltaY - leftEdge * -deltaY + gridRect.bottom();
+                    points[i] = (ceilEdge + qreal(i)) * -deltaY - leftEdge * -deltaY + gridRect.bottom();
                 return points;
             }
             void ChartLogValueAxisY::updateGeometry()
             {
-                const QVector<qreal> &layout = ChartAxis::layout();
+                const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), layout.size(), m_axis->labelFormat()));
             {
                 Q_UNUSED(constraint)
-                QFontMetrics fn(font());
+                QFontMetrics fn(axis()->labelsFont());
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);

src/axis/logvalueaxis/chartlogvalueaxisy_p.h +1 -3

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLogValueAxis;
-            class ChartPresenter;
             class ChartLogValueAxisY : public VerticalAxis
             {
                 Q_OBJECT
             public:
-                ChartLogValueAxisY(QLogValueAxis *axis, QGraphicsItem* item);
+                ChartLogValueAxisY(QLogValueAxis *axis, QGraphicsItem *item);
                 ~ChartLogValueAxisY();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
-                void handleAxisUpdated();
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();

src/axis/logvalueaxis/qlogvalueaxis.cpp +20 -8

             #include "qlogvalueaxis_p.h"
             #include "chartlogvalueaxisx_p.h"
             #include "chartlogvalueaxisy_p.h"
+            #include "polarchartlogvalueaxisangular_p.h"
+            #include "polarchartlogvalueaxisradial_p.h"
             #include "abstractdomain_p.h"
             #include <float.h>
             #include <cmath>
                 }
             }
-            void QLogValueAxisPrivate::initializeGraphics(QGraphicsItem* parent)
+            void QLogValueAxisPrivate::initializeGraphics(QGraphicsItem *parent)
             {
                 Q_Q(QLogValueAxis);
-                ChartAxis* axis(0);
+                ChartAxisElement *axis(0);
-                if (orientation() == Qt::Vertical)
-                    axis = new ChartLogValueAxisY(q,parent);
+                if (m_chart->chartType() == QChart::ChartTypeCartesian) {
-                if (orientation() == Qt::Horizontal)
+                    if (orientation() == Qt::Vertical)
-                    axis = new ChartLogValueAxisX(q,parent);
+                        axis = new ChartLogValueAxisY(q,parent);
+                    if (orientation() == Qt::Horizontal)
+                        axis = new ChartLogValueAxisX(q,parent);
+                }
+                if (m_chart->chartType() == QChart::ChartTypePolar) {
+                    if (orientation() == Qt::Vertical)
+                        axis = new PolarChartLogValueAxisRadial(q, parent);
+                    if (orientation() == Qt::Horizontal)
+                        axis = new PolarChartLogValueAxisAngular(q, parent);
+                }
                 m_item.reset(axis);
                 QAbstractAxisPrivate::initializeGraphics(parent);
             void QLogValueAxisPrivate::initializeDomain(AbstractDomain *domain)
             {
                 if (orientation() == Qt::Vertical) {
-                    if(!qFuzzyCompare(m_max, m_min)) {
+                    if (!qFuzzyCompare(m_max, m_min)) {
                         domain->setRangeY(m_min, m_max);
                     } else if ( domain->minY() > 0) {
                         setRange(domain->minY(), domain->maxY());
                     }
                 }
                 if (orientation() == Qt::Horizontal) {
-                    if(!qFuzzyCompare(m_max, m_min)) {
+                    if (!qFuzzyCompare(m_max, m_min)) {
                         domain->setRangeX(m_min, m_max);
                     } else if (domain->minX() > 0){
                         setRange(domain->minX(), domain->maxX());

src/axis/qabstractaxis.cpp +5 -5

             /*!
               \property QAbstractAxis::alignment
-              The alignment of the axis. Either Qt::AlignLeft or Qt::AlignBottom.
+              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. Either Qt.AlignLeft or Qt.AlignBottom.
+              The alignment of the axis. Can be Qt.AlignLeft, Qt.AlignRight, Qt.AlignBottom, or Qt.AlignTop.
             */
             /*!
             void QAbstractAxisPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
-                ChartAxis* axis = m_item.data();
+                ChartAxisElement *axis = m_item.data();
                 Q_ASSERT(axis);
-                if(options.testFlag(QChart::GridAxisAnimations)) {
+                if (options.testFlag(QChart::GridAxisAnimations)) {
                     axis->setAnimation(new AxisAnimation(axis));
-                }else{
+                } else {
                     axis->setAnimation(0);
                 }
             }

src/axis/qabstractaxis.h +13 -12

             Q_SIGNALS:
                 void visibleChanged(bool visible);
-                void linePenChanged(const QPen& pen);
+                void linePenChanged(const QPen &pen);
                 void lineVisibleChanged(bool visible);
                 void labelsVisibleChanged(bool visible);
-                void labelsPenChanged(const QPen& pen);
+                void labelsPenChanged(const QPen &pen);
-                void labelsBrushChanged(const QBrush& brush);
+                void labelsBrushChanged(const QBrush &brush);
-                void labelsFontChanged(const QFont& pen);
+                void labelsFontChanged(const QFont &pen);
                 void labelsAngleChanged(int angle);
-                void gridLinePenChanged(const QPen& pen);
+                void gridLinePenChanged(const QPen &pen);
                 void gridVisibleChanged(bool visible);
                 void colorChanged(QColor color);
                 void labelsColorChanged(QColor color);
-                void titleTextChanged(const QString& title);
+                void titleTextChanged(const QString &title);
-                void titlePenChanged(const QPen& pen);
+                void titlePenChanged(const QPen &pen);
-                void titleBrushChanged(const QBrush& brush);
+                void titleBrushChanged(const QBrush &brush);
                 void titleVisibleChanged(bool visible);
-                void titleFontChanged(const QFont& font);
+                void titleFontChanged(const QFont &font);
                 void shadesVisibleChanged(bool visible);
                 void shadesColorChanged(QColor color);
                 void shadesBorderColorChanged(QColor color);
-                void shadesPenChanged(const QPen& pen);
+                void shadesPenChanged(const QPen &pen);
-                void shadesBrushChanged(const QBrush& brush);
+                void shadesBrushChanged(const QBrush &brush);
             protected:
                 QScopedPointer<QAbstractAxisPrivate> d_ptr;
                 Q_DISABLE_COPY(QAbstractAxis)
                 friend class ChartDataSet;
-                friend class ChartAxis;
                 friend class ChartPresenter;
                 friend class ChartThemeManager;
                 friend class AbstractDomain;
+                friend class ChartAxisElement;
+                friend class XYChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qabstractaxis_p.h +4 -4

             #define QABSTRACTAXIS_P_H
             #include "qabstractaxis.h"
-            #include "chartaxis_p.h"
+            #include "chartaxiselement_p.h"
             #include "qchart.h"
             #include <QDebug>
                 void setAlignment( Qt::Alignment alignment);
                 virtual void initializeDomain(AbstractDomain *domain) = 0;
-                virtual void initializeGraphics(QGraphicsItem* parent) = 0;
+                virtual void initializeGraphics(QGraphicsItem *parent) = 0;
                 virtual void initializeTheme(ChartTheme* theme, bool forced = false);
                 virtual void initializeAnimations(QChart::AnimationOptions options);
                 virtual qreal min() = 0;
                 virtual qreal max() = 0;
-                ChartAxis* axisItem() { return m_item.data(); }
+                ChartAxisElement *axisItem() { return m_item.data(); }
             public Q_SLOTS:
                 void handleRangeChanged(qreal min, qreal max);
             protected:
                 QAbstractAxis *q_ptr;
                 QChart *m_chart;
-                QScopedPointer<ChartAxis> m_item;
+                QScopedPointer<ChartAxisElement> m_item;
             private:
                 QList<QAbstractSeries*> m_series;

src/axis/valueaxis/chartvalueaxisx.cpp +7 -7

             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include "qvalueaxis.h"
-            #include "chartlayout_p.h"
+            #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartValueAxisX::ChartValueAxisX(QValueAxis *axis, QGraphicsItem* item )
+            ChartValueAxisX::ChartValueAxisX(QValueAxis *axis, QGraphicsItem *item )
                 : HorizontalAxis(axis, item),
                   m_axis(axis)
             {
-            	QObject::connect(m_axis,SIGNAL(tickCountChanged(int)),this, SLOT(handleTickCountChanged(int)));
+                QObject::connect(m_axis, SIGNAL(tickCountChanged(int)), this, SLOT(handleTickCountChanged(int)));
-                QObject::connect(m_axis,SIGNAL(labelFormatChanged(QString)),this, SLOT(handleLabelFormatChanged(QString)));
+                QObject::connect(m_axis, SIGNAL(labelFormatChanged(QString)), this, SLOT(handleLabelFormatChanged(QString)));
             }
             ChartValueAxisX::~ChartValueAxisX()
             void ChartValueAxisX::updateGeometry()
             {
-                const QVector<qreal>& layout = ChartAxis::layout();
+                const QVector<qreal>& layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
-                setLabels(createValueLabels(min(),max(),layout.size(),m_axis->labelFormat()));
+                setLabels(createValueLabels(min(), max(), layout.size(), m_axis->labelFormat()));
                 HorizontalAxis::updateGeometry();
             }
             {
                 Q_UNUSED(constraint)
-                QFontMetrics fn(font());
+                QFontMetrics fn(axis()->labelsFont());
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);

src/axis/valueaxis/chartvalueaxisx_p.h +1 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QValueAxis;
-            class ChartPresenter;
             class ChartValueAxisX : public HorizontalAxis
             {
             	Q_OBJECT
             public:
-                ChartValueAxisX(QValueAxis *axis, QGraphicsItem* item = 0);
+                ChartValueAxisX(QValueAxis *axis, QGraphicsItem *item = 0);
                 ~ChartValueAxisX();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;

src/axis/valueaxis/chartvalueaxisy.cpp +6 -6

             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include "qvalueaxis.h"
-            #include "chartlayout_p.h"
+            #include "abstractchartlayout_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartValueAxisY::ChartValueAxisY(QValueAxis *axis, QGraphicsItem* item)
+            ChartValueAxisY::ChartValueAxisY(QValueAxis *axis, QGraphicsItem *item)
                 : VerticalAxis(axis, item),
                   m_axis(axis)
             {
-            	QObject::connect(m_axis,SIGNAL(tickCountChanged(int)),this, SLOT(handleTickCountChanged(int)));
+                QObject::connect(m_axis, SIGNAL(tickCountChanged(int)), this, SLOT(handleTickCountChanged(int)));
-                QObject::connect(m_axis,SIGNAL(labelFormatChanged(QString)),this, SLOT(handleLabelFormatChanged(QString)));
+                QObject::connect(m_axis, SIGNAL(labelFormatChanged(QString)), this, SLOT(handleLabelFormatChanged(QString)));
             }
             ChartValueAxisY::~ChartValueAxisY()
             void ChartValueAxisY::updateGeometry()
             {
-                const QVector<qreal> &layout = ChartAxis::layout();
+                const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createValueLabels(min(),max(),layout.size(),m_axis->labelFormat()));
             {
                 Q_UNUSED(constraint)
-                QFontMetrics fn(font());
+                QFontMetrics fn(axis()->labelsFont());
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
                 QStringList ticksList = createValueLabels(min(),max(),m_axis->tickCount(),m_axis->labelFormat());

src/axis/valueaxis/chartvalueaxisy_p.h +1 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QValueAxis;
-            class ChartPresenter;
             class ChartValueAxisY : public VerticalAxis
             {
             	Q_OBJECT
             public:
-                ChartValueAxisY(QValueAxis *axis, QGraphicsItem* item = 0);
+                ChartValueAxisY(QValueAxis *axis, QGraphicsItem *item = 0);
                 ~ChartValueAxisY();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;

src/axis/valueaxis/qvalueaxis.cpp +22 -14

             #include "chartvalueaxisx_p.h"
             #include "chartvalueaxisy_p.h"
             #include "abstractdomain_p.h"
+            #include "polarchartvalueaxisangular_p.h"
+            #include "polarchartvalueaxisradial_p.h"
             #include "chartdataset_p.h"
             #include "chartpresenter_p.h"
             #include "charttheme_p.h"
                 }
             }
-            void QValueAxisPrivate::initializeGraphics(QGraphicsItem* parent)
+            void QValueAxisPrivate::initializeGraphics(QGraphicsItem *parent)
             {
                 Q_Q(QValueAxis);
-                ChartAxis* axis(0);
+                ChartAxisElement *axis(0);
-                if (orientation() == Qt::Vertical)
-                    axis = new ChartValueAxisY(q,parent);
+                if (m_chart->chartType() == QChart::ChartTypeCartesian) {
-                if (orientation() == Qt::Horizontal)
+                    if (orientation() == Qt::Vertical)
-                    axis = new ChartValueAxisX(q,parent);
+                        axis = new ChartValueAxisY(q,parent);
+                    if (orientation() == Qt::Horizontal)
+                        axis = new ChartValueAxisX(q,parent);
+                }
+                if (m_chart->chartType() == QChart::ChartTypePolar) {
+                    if (orientation() == Qt::Vertical)
+                        axis = new PolarChartValueAxisRadial(q, parent);
+                    if (orientation() == Qt::Horizontal)
+                        axis = new PolarChartValueAxisAngular(q, parent);
+                }
                 m_item.reset(axis);
                 QAbstractAxisPrivate::initializeGraphics(parent);
             void QValueAxisPrivate::initializeDomain(AbstractDomain *domain)
             {
                 if (orientation() == Qt::Vertical) {
-                    if(!qFuzzyIsNull(m_max - m_min)) {
+                    if (!qFuzzyIsNull(m_max - m_min))
                         domain->setRangeY(m_min, m_max);
+                    else
-                    else {
                         setRange(domain->minY(), domain->maxY());
                 }
                 if (orientation() == Qt::Horizontal) {
-                    if(!qFuzzyIsNull(m_max - m_min)) {
+                    if (!qFuzzyIsNull(m_max - m_min))
                         domain->setRangeX(m_min, m_max);
+                    else
-                    else {
                         setRange(domain->minX(), domain->maxX());
                 }
             }

src/axis/verticalaxis.cpp +26 -30

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            VerticalAxis::VerticalAxis(QAbstractAxis *axis, QGraphicsItem* item, bool intervalAxis)
+            VerticalAxis::VerticalAxis(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
-                : ChartAxis(axis, item, intervalAxis)
+                : CartesianChartAxis(axis, item, intervalAxis)
             {
             }
             VerticalAxis::~VerticalAxis()
             {
             }
             void VerticalAxis::updateGeometry()
             {
-                const QVector<qreal> &layout = ChartAxis::layout();
+                const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 QStringList labelList = labels();
-                QList<QGraphicsItem *> lines = lineItems();
+                QList<QGraphicsItem *> lines = gridItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
-                QList<QGraphicsItem *> axis = arrowItems();
+                QList<QGraphicsItem *> arrow = arrowItems();
-                QGraphicsSimpleTextItem* title = titleItem();
+                QGraphicsSimpleTextItem *title = titleItem();
                 Q_ASSERT(labels.size() == labelList.size());
                 Q_ASSERT(layout.size() == labelList.size());
                 //arrow
-                QGraphicsLineItem *arrowItem = static_cast<QGraphicsLineItem*>(axis.at(0));
+                QGraphicsLineItem *arrowItem = static_cast<QGraphicsLineItem*>(arrow.at(0));
                 //arrow position
-                if (alignment()==Qt::AlignLeft)
+                if (axis()->alignment() == Qt::AlignLeft)
-                    arrowItem->setLine( axisRect.right() , gridRect.top(), axisRect.right(), gridRect.bottom());
+                    arrowItem->setLine(axisRect.right(), gridRect.top(), axisRect.right(), gridRect.bottom());
-                else if(alignment()==Qt::AlignRight)
+                else if (axis()->alignment() == Qt::AlignRight)
-                    arrowItem->setLine( axisRect.left() , gridRect.top(), axisRect.left(), gridRect.bottom());
+                    arrowItem->setLine(axisRect.left(), gridRect.top(), axisRect.left(), gridRect.bottom());
-                QFontMetrics fn(font());
+                QFontMetrics fn(axis()->labelsFont());
                 //title
                 int titlePad = 0;
                 QRectF titleBoundingRect;
-                if (!titleText().isEmpty() && titleItem()->isVisible()) {
+                QString titleText = axis()->titleText();
+                if (!titleText.isEmpty() && titleItem()->isVisible()) {
                     QFontMetrics fn(title->font());
                     int size(0);
                     size = gridRect.height();
-                    QString titleText = this->titleText();
                     if (fn.boundingRect(titleText).width() > size) {
                         QString string = titleText + "...";
                         while (fn.boundingRect(string).width() > size && string.length() > 3)
-                        string.remove(string.length() - 4, 1);
+                            string.remove(string.length() - 4, 1);
                         title->setText(string);
+                    } else {
-                    else {
                         title->setText(titleText);
                     }
                     titleBoundingRect = title->boundingRect();
                     QPointF center = gridRect.center() - titleBoundingRect.center();
-                    if (alignment() == Qt::AlignLeft) {
+                    if (axis()->alignment() == Qt::AlignLeft) {
                         title->setPos(axisRect.left() - titleBoundingRect.width() / 2 + titleBoundingRect.height() / 2 + titlePad, center.y());
                     }
-                    else if (alignment() == Qt::AlignRight) {
+                    else if (axis()->alignment() == Qt::AlignRight) {
                         title->setPos(axisRect.right() - titleBoundingRect.width() / 2 - titleBoundingRect.height() / 2 - titlePad, center.y());
                     }
                     title->setTransformOriginPoint(titleBoundingRect.center());
                 }
                 for (int i = 0; i < layout.size(); ++i) {
                     //items
                     QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem *>(lines.at(i));
-                    QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
+                    QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(arrow.at(i + 1));
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
                     //grid line
-                    gridItem->setLine(gridRect.left() , layout[i], gridRect.right(), layout[i]);
+                    gridItem->setLine(gridRect.left(), layout[i], gridRect.right(), layout[i]);
                     //label text wrapping
                     QString text = labelList.at(i);
                     int widthDiff = rect.width() - boundingRect.width();
                     //ticks and label position
-                    if (alignment() == Qt::AlignLeft) {
+                    if (axis()->alignment() == Qt::AlignLeft) {
                         labelItem->setPos(axisRect.right() - rect.width() + (widthDiff / 2) - labelPadding(), layout[i] - center.y());
                         tickItem->setLine(axisRect.right() - labelPadding(), layout[i], axisRect.right(), layout[i]);
-                    } else if (alignment() == Qt::AlignRight) {
+                    } else if (axis()->alignment() == Qt::AlignRight) {
                         labelItem->setPos(axisRect.left() + labelPadding() - (widthDiff / 2), layout[i] - center.y());
                         tickItem->setLine(axisRect.left(), layout[i], axisRect.left() + labelPadding(), layout[i]);
                     }
                     gridLine = static_cast<QGraphicsLineItem *>(lines.at(layout.size()));
                     gridLine->setLine(gridRect.left(), gridRect.top(), gridRect.right(), gridRect.top());
                     gridLine->setVisible(true);
-                    gridLine = static_cast<QGraphicsLineItem*>(lines.at(layout.size()+1));
+                    gridLine = static_cast<QGraphicsLineItem*>(lines.at(layout.size() + 1));
                     gridLine->setLine(gridRect.left(), gridRect.bottom(), gridRect.right(), gridRect.bottom());
                     gridLine->setVisible(true);
                 }
             {
                 Q_UNUSED(constraint);
-                QFontMetrics fn(titleFont());
+                QFontMetrics fn(axis()->titleFont());
-                QSizeF sh(0,0);
+                QSizeF sh(0, 0);
-                if (titleText().isEmpty() || !titleItem()->isVisible())
+                if (axis()->titleText().isEmpty() || !titleItem()->isVisible())
                     return sh;
                 switch (which) {

src/axis/verticalaxis_p.h +3 -3

             #ifndef VERTICALAXIS_P_H_
             #define VERTICALAXIS_P_H_
-            #include "chartaxis_p.h"
+            #include "cartesianchartaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class VerticalAxis : public ChartAxis
+            class VerticalAxis : public CartesianChartAxis
             {
             public:
-                VerticalAxis(QAbstractAxis *axis, QGraphicsItem* item = 0, bool intervalAxis = false);
+                VerticalAxis(QAbstractAxis *axis, QGraphicsItem *item = 0, bool intervalAxis = false);
                 ~VerticalAxis();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
             protected:

src/chartdataset.cpp +140 -67

             #include "qpieseries.h"
             #include "chartitem_p.h"
             #include "xydomain_p.h"
+            #include "xypolardomain_p.h"
             #include "xlogydomain_p.h"
             #include "logxydomain_p.h"
             #include "logxlogydomain_p.h"
+            #include "xlogypolardomain_p.h"
+            #include "logxypolardomain_p.h"
+            #include "logxlogypolardomain_p.h"
             #ifndef QT_ON_ARM
             #include "qdatetimeaxis.h"
                     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;
+                    }
+                    series->d_ptr->setDomain(new XYPolarDomain());
+                } else {
+                    series->d_ptr->setDomain(new XYDomain());
+                }
                 series->d_ptr->initializeDomain();
                 m_seriesList.append(series);
             /*
              * This method adds axis to chartdataset, axis ownership is taken from caller.
              */
-            void ChartDataSet::addAxis(QAbstractAxis *axis,Qt::Alignment aligment)
+            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.");
                 axis->d_ptr->setAlignment(aligment);
-                if(!axis->alignment()) {
+                if (!axis->alignment()) {
-                    qWarning()<< QObject::tr("No alignment specified !");
+                    qWarning() << QObject::tr("No alignment specified !");
                     return;
                 };
-                QSharedPointer<AbstractDomain> domain(new XYDomain());
+                AbstractDomain *newDomain;
+                if (m_chart && m_chart->chartType() == QChart::ChartTypePolar) {
+                    foreach (QAbstractAxis *existingAxis, axes()) {
+                        if (existingAxis->orientation() == axis->orientation()) {
+                            qWarning() << QObject::tr("Cannot add multiple axes of same orientation to a polar chart!");
+                            return;
+                        }
+                    }
+                    newDomain = new XYPolarDomain();
+                } else {
+                    newDomain = new XYDomain();
+                }
+                QSharedPointer<AbstractDomain> domain(newDomain);
                 axis->d_ptr->initializeDomain(domain.data());
                 axis->setParent(this);
                 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;
             }
             /*
              * This method attaches axis to series, return true if success.
              */
-            bool ChartDataSet::attachAxis(QAbstractSeries* series,QAbstractAxis *axis)
+            bool ChartDataSet::attachAxis(QAbstractSeries *series,QAbstractAxis *axis)
             {
                 Q_ASSERT(series);
                 Q_ASSERT(axis);
-                QList<QAbstractSeries* > attachedSeriesList = axis->d_ptr->m_series;
+                QList<QAbstractSeries *> attachedSeriesList = axis->d_ptr->m_series;
-                QList<QAbstractAxis* > attachedAxisList = series->d_ptr->m_axes;
+                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;
                 }
-                AbstractDomain* domain = series->d_ptr->domain();
+                AbstractDomain *domain = series->d_ptr->domain();
                 AbstractDomain::DomainType type = selectDomain(attachedAxisList<<axis);
-                if(type == AbstractDomain::UndefinedDomain) return false;
+                if (type == AbstractDomain::UndefinedDomain) return false;
-                if(domain->type()!=type){
+                if (domain->type() != type) {
                     AbstractDomain *old = domain;
-                    domain =  createDomain(type);
+                    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)
+                    return false;
+                if (!domain->attachAxis(axis))
+                    return false;
-                if(!domain->attachAxis(axis)) return false;
+                QList<AbstractDomain *> blockedDomains;
+                domain->blockRangeSignals(true);
+                blockedDomains << domain;
-                if(domain!=series->d_ptr->domain()){
+                if (domain != series->d_ptr->domain()) {
-                    foreach(QAbstractAxis* axis,series->d_ptr->m_axes){
+                    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->initializeAxes();
                 axis->d_ptr->initializeDomain(domain);
+                foreach (AbstractDomain *blockedDomain, blockedDomains)
+                    blockedDomain->blockRangeSignals(false);
                 return true;
             }
             {
             	Q_ASSERT(!series.isEmpty());
-            	AbstractDomain* domain = series.first()->d_ptr->domain();
+                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++) {
+                for (int i = 1; i< series.size(); i++) {
-            		AbstractDomain* domain = series[i]->d_ptr->domain();
+                    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);
             	}
                 return point;
             }
-            QList<QAbstractAxis*> ChartDataSet::axes() const
+            QList<QAbstractAxis *> ChartDataSet::axes() const
             {
                return m_axisList;
             }
                 return m_seriesList;
             }
-            AbstractDomain::DomainType ChartDataSet::selectDomain(QList<QAbstractAxis*> axes)
+            AbstractDomain::DomainType ChartDataSet::selectDomain(QList<QAbstractAxis *> axes)
             {
                 enum Type {
                     Undefined = 0,
                 int horizontal(Undefined);
                 int vertical(Undefined);
-                foreach(QAbstractAxis* axis, axes)
+                // Assume cartesian chart type, unless chart is set
+                QChart::ChartType chartType(QChart::ChartTypeCartesian);
-                    switch(axis->type()) {
+                if (m_chart)
-                        case QAbstractAxis::AxisTypeLogValue:
+                    chartType = m_chart->chartType();
-                        if(axis->orientation()==Qt::Horizontal) {
-                            horizontal|=LogType;
-                        if(axis->orientation()==Qt::Vertical) {
-                            vertical|=LogType;
+                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::AxisTypeValue:
-                        case QAbstractAxis::AxisTypeBarCategory:
+                    case QAbstractAxis::AxisTypeBarCategory:
-                        case QAbstractAxis::AxisTypeCategory:
+                    case QAbstractAxis::AxisTypeCategory:
-                        case QAbstractAxis::AxisTypeDateTime:
+                    case QAbstractAxis::AxisTypeDateTime:
-                        if(axis->orientation()==Qt::Horizontal) {
+                        if (axis->orientation() == Qt::Horizontal)
-                            horizontal|=ValueType;
+                            horizontal |= ValueType;
+                        if (axis->orientation() == Qt::Vertical)
-                        if(axis->orientation()==Qt::Vertical) {
+                            vertical |= ValueType;
-                            vertical|=ValueType;
                         break;
-                        default:
+                    default:
-                        qWarning()<<"Undefined type";
+                        qWarning() << "Undefined type";
                         break;
                     }
                 }
-                if(vertical==Undefined) vertical=ValueType;
+                if (vertical == Undefined)
-                if(horizontal==Undefined) horizontal=ValueType;
+                    vertical = ValueType;
+                if (horizontal == Undefined)
+                    horizontal = ValueType;
-                if(vertical==ValueType && horizontal== ValueType) {
+                if (vertical == ValueType && horizontal == ValueType) {
-                    return AbstractDomain::XYDomain;
+                    if (chartType == QChart::ChartTypeCartesian)
+                        return AbstractDomain::XYDomain;
+                    else if (chartType == QChart::ChartTypePolar)
+                        return AbstractDomain::XYPolarDomain;
                 }
-                if(vertical==LogType && horizontal== ValueType) {
+                if (vertical == LogType && horizontal == ValueType) {
-                    return AbstractDomain::XLogYDomain;
+                    if (chartType == QChart::ChartTypeCartesian)
+                        return AbstractDomain::XLogYDomain;
+                    if (chartType == QChart::ChartTypePolar)
+                        return AbstractDomain::XLogYPolarDomain;
                 }
-                if(vertical==ValueType && horizontal== LogType) {
+                if (vertical == ValueType && horizontal == LogType) {
-                    return AbstractDomain::LogXYDomain;
+                    if (chartType == QChart::ChartTypeCartesian)
+                        return AbstractDomain::LogXYDomain;
+                    else if (chartType == QChart::ChartTypePolar)
+                        return AbstractDomain::LogXYPolarDomain;
                 }
-                if(vertical==LogType && horizontal== LogType) {
+                if (vertical == LogType && horizontal == LogType) {
-                    return AbstractDomain::LogXLogYDomain;
+                    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)
+                switch (type)
+                {
-            		case AbstractDomain::LogXLogYDomain:
+                case AbstractDomain::LogXLogYDomain:
-            			return new LogXLogYDomain();
+                    return new LogXLogYDomain();
-            		case AbstractDomain::XYDomain:
+                case AbstractDomain::XYDomain:
-            			return new XYDomain();
+                    return new XYDomain();
-            		case AbstractDomain::XLogYDomain:
+                case AbstractDomain::XLogYDomain:
-            			return new XLogYDomain();
+                    return new XLogYDomain();
-            		case AbstractDomain::LogXYDomain:
+                case AbstractDomain::LogXYDomain:
-            			return new LogXYDomain();
+                    return new LogXYDomain();
-            		default:
+                case AbstractDomain::XYPolarDomain:
-            			return 0;
+                    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"

src/chartpresenter.cpp +21 -17

             #include "chartanimation_p.h"
             #include "qabstractseries_p.h"
             #include "qareaseries.h"
-            #include "chartaxis_p.h"
+            #include "chartaxiselement_p.h"
             #include "chartbackground_p.h"
-            #include "chartlayout_p.h"
+            #include "cartesianchartlayout_p.h"
+            #include "polarchartlayout_p.h"
             #include "charttitle_p.h"
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartPresenter::ChartPresenter(QChart *chart)
+            ChartPresenter::ChartPresenter(QChart *chart, QChart::ChartType type)
                 : QObject(chart),
                   m_chart(chart),
                   m_options(QChart::NoAnimation),
                   m_state(ShowState),
-                  m_layout(new ChartLayout(this)),
                   m_background(0),
                   m_title(0)
             {
+                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()
             void ChartPresenter::setGeometry(const QRectF rect)
             {
-            	if(m_rect != rect) {
+                if (m_rect != rect) {
-            		m_rect=rect;
+                    m_rect = rect;
-            		foreach (ChartItem *chart, m_chartItems){
+                    foreach (ChartItem *chart, m_chartItems) {
-            			chart->domain()->setSize(rect.size());
+                        chart->domain()->setSize(rect.size());
-            			chart->setPos(rect.topLeft());
+                        chart->setPos(rect.topLeft());
+                    }
+                }
             }
             QRectF ChartPresenter::geometry() const
             {
-            	return m_rect;
+                return m_rect;
             }
             void ChartPresenter::handleAxisAdded(QAbstractAxis *axis)
             {
                 axis->d_ptr->initializeGraphics(rootItem());
                 axis->d_ptr->initializeAnimations(m_options);
-                ChartAxis *item = axis->d_ptr->axisItem();
+                ChartAxisElement *item = axis->d_ptr->axisItem();
                 item->setPresenter(this);
                 item->setThemeManager(m_chart->d_ptr->m_themeManager);
                 m_axisItems<<item;
             void ChartPresenter::handleAxisRemoved(QAbstractAxis *axis)
             {
-                ChartAxis *item  = axis->d_ptr->m_item.take();
+                ChartAxisElement *item  = axis->d_ptr->m_item.take();
                 item->hide();
                 item->disconnect();
                 item->deleteLater();
             }
-            ChartLayout *ChartPresenter::layout()
+            AbstractChartLayout *ChartPresenter::layout()
             {
                 return m_layout;
             }
                 return m_background;
             }
-            QList<ChartAxis *>  ChartPresenter::axisItems() const
+            QList<ChartAxisElement *>  ChartPresenter::axisItems() const
             {
                 return m_axisItems;
             }

src/chartpresenter_p.h +9 -10

             class QAbstractSeries;
             class ChartDataSet;
             class AbstractDomain;
-            class ChartAxis;
+            class ChartAxisElement;
             class ChartAnimator;
             class ChartBackground;
             class ChartTitle;
             class ChartAnimation;
-            class ChartLayout;
+            class AbstractChartLayout;
             class ChartPresenter: public QObject
             {
                     ZoomOutState
                 };
-                ChartPresenter(QChart *chart);
+                ChartPresenter(QChart *chart, QChart::ChartType type);
                 virtual ~ChartPresenter();
                 QGraphicsItem *rootItem(){ return m_chart; }
                 ChartBackground *backgroundElement();
                 ChartTitle *titleElement();
-                QList<ChartAxis *> axisItems() const;
+                QList<ChartAxisElement *> axisItems() const;
                 QList<ChartItem *> chartItems() const;
-                ChartItem* chartElement(QAbstractSeries* series) const;
-                ChartAxis* chartElement(QAbstractAxis* axis) const;
                 QLegend *legend();
                 void setBackgroundBrush(const QBrush &brush);
                 void setState(State state,QPointF point);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
-                ChartLayout *layout();
+                AbstractChartLayout *layout();
+                QChart::ChartType chartType() const { return m_chart->chartType(); }
             private:
                 void createBackgroundItem();
             private:
                 QChart *m_chart;
                 QList<ChartItem *> m_chartItems;
-                QList<ChartAxis *> m_axisItems;
+                QList<ChartAxisElement *> m_axisItems;
                 QList<QAbstractSeries *> m_series;
                 QList<QAbstractAxis *> m_axes;
                 QChart::AnimationOptions m_options;
                 State m_state;
                 QPointF m_statePoint;
                 QList<ChartAnimation *> m_animations;
-                ChartLayout *m_layout;
+                AbstractChartLayout *m_layout;
                 ChartBackground *m_background;
                 ChartTitle *m_title;
                 QRectF m_rect;

src/domain/abstractdomain.cpp +24 -13

             {
             }
-            void AbstractDomain::setSize(const QSizeF& size)
+            void AbstractDomain::setSize(const QSizeF &size)
             {
             	if(m_size!=size)
             	{
             void AbstractDomain::blockRangeSignals(bool block)
             {
-                if(m_signalsBlocked!=block){
+                if (m_signalsBlocked!=block) {
                     m_signalsBlocked=block;
-                    if(!block) {
+                    if (!block) {
                         emit rangeHorizontalChanged(m_minX,m_maxX);
                         emit rangeVerticalChanged(m_minY,m_maxY);
                     }
                 return q * z;
             }
-            bool AbstractDomain::attachAxis(QAbstractAxis* axis)
+            bool AbstractDomain::attachAxis(QAbstractAxis *axis)
             {
-            	if(axis->orientation()==Qt::Vertical) {
+                if (axis->orientation() == Qt::Vertical) {
             		QObject::connect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), this, SLOT(handleVerticalAxisRangeChanged(qreal,qreal)));
             		QObject::connect(this, SIGNAL(rangeVerticalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
             	}
-            	if(axis->orientation()==Qt::Horizontal) {
+                if (axis->orientation() == Qt::Horizontal) {
             		QObject::connect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), this, SLOT(handleHorizontalAxisRangeChanged(qreal,qreal)));
             		QObject::connect(this, SIGNAL(rangeHorizontalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
             	}
             	return true;
             }
-            bool AbstractDomain::detachAxis(QAbstractAxis* axis)
+            bool AbstractDomain::detachAxis(QAbstractAxis *axis)
             {
-            	if(axis->orientation()==Qt::Vertical) {
+                if (axis->orientation() == Qt::Vertical) {
             		QObject::disconnect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), this, SLOT(handleVerticalAxisRangeChanged(qreal,qreal)));
             		QObject::disconnect(this, SIGNAL(rangeVerticalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
             	}
-            	if(axis->orientation()==Qt::Horizontal) {
+                if (axis->orientation() == Qt::Horizontal) {
             		QObject::disconnect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), this, SLOT(handleHorizontalAxisRangeChanged(qreal,qreal)));
             		QObject::disconnect(this, SIGNAL(rangeHorizontalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
             	}
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const AbstractDomain &domain1, const AbstractDomain &domain2)
             {
-                return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
+                return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX)
-                        qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
+                        && qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY)
-                        qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
+                        && qFuzzyIsNull(domain1.m_minX - domain2.m_minX)
-                        qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
+                        && qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
             }
                 return dbg.maybeSpace();
             }
+            // This function adjusts min/max ranges to failsafe values if negative/zero values are attempted.
+            void AbstractDomain::adjustLogDomainRanges(qreal &min, qreal &max)
+            {
+                if (min <= 0) {
+                   min = 1.0;
+                   if (max <= min)
+                       max = min + 1.0;
+                }
+            }
             #include "moc_abstractdomain_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain/abstractdomain_p.h +15 -5

             {
                 Q_OBJECT
             public:
-                enum DomainType { UndefinedDomain, XYDomain, XLogYDomain, LogXYDomain, LogXLogYDomain };
+                enum DomainType { UndefinedDomain,
+                                  XYDomain,
+                                  XLogYDomain,
+                                  LogXYDomain,
+                                  LogXLogYDomain,
+                                  XYPolarDomain,
+                                  XLogYPolarDomain,
+                                  LogXYPolarDomain,
+                                  LogXLogYPolarDomain };
             public:
                 explicit AbstractDomain(QObject *object = 0);
                 virtual ~AbstractDomain();
-                void setSize(const QSizeF& size);
+                virtual void setSize(const QSizeF &size);
                 QSizeF size() const;
                 virtual DomainType type() = 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 QList<QPointF> &vector) const = 0;
-                virtual bool attachAxis(QAbstractAxis* axis);
+                virtual bool attachAxis(QAbstractAxis *axis);
-                virtual bool detachAxis(QAbstractAxis* axis);
+                virtual bool detachAxis(QAbstractAxis *axis);
                 static void looseNiceNumbers(qreal &min, qreal &max, int &ticksCount);
                 static qreal niceNumber(qreal x, bool ceiling);
                 void handleHorizontalAxisRangeChanged(qreal min,qreal max);
             protected:
+                void adjustLogDomainRanges(qreal &min, qreal &max);
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;

src/domain/domain.pri +12 -2

             SOURCES += \
                 $$PWD/abstractdomain.cpp \
+                $$PWD/polardomain.cpp \
                 $$PWD/xydomain.cpp \
+                $$PWD/xypolardomain.cpp \
                 $$PWD/xlogydomain.cpp \
+                $$PWD/xlogypolardomain.cpp \
                 $$PWD/logxydomain.cpp \
-                $$PWD/logxlogydomain.cpp
+                $$PWD/logxypolardomain.cpp \
+                $$PWD/logxlogydomain.cpp \
+                $$PWD/logxlogypolardomain.cpp
             PRIVATE_HEADERS += \
                 $$PWD/abstractdomain_p.h \
+                $$PWD/polardomain_p.h \
                 $$PWD/xydomain_p.h \
+                $$PWD/xypolardomain_p.h \
                 $$PWD/xlogydomain_p.h \
+                $$PWD/xlogypolardomain_p.h \
                 $$PWD/logxydomain_p.h \
-                $$PWD/logxlogydomain_p.h
+                $$PWD/logxypolardomain_p.h \
+                $$PWD/logxlogydomain_p.h \
+                $$PWD/logxlogypolardomain_p.h

src/domain/logxlogydomain.cpp +17 -14

                 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;
                     qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
                     m_logLeftY = logMinY < logMaxY ? logMinY : logMaxY;
                     m_logRightY = logMinY > logMaxY ? logMinY : logMaxY;
-                    if(!m_signalsBlocked)
+                    if (!m_signalsBlocked)
                         emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                     ok = true;
                     return QPointF(x, y);
                 } else {
-                    qWarning() << "Logarithm of negative value is undefined. Empty layout returned";
+                    qWarning() << "Logarithm of negative value is undefined. Empty layout returned.";
                     ok = false;
                     return QPointF();
                 }
             }
-            QVector<QPointF> LogXLogYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
+            QVector<QPointF> LogXLogYDomain::calculateGeometryPoints(const QList<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);
                         result[i].setX(x);
                         result[i].setY(y);
                     } else {
-                        qWarning() << "Logarithm of negative value is undefined. Empty layout returned";
+                        qWarning() << "Logarithm of negative value is undefined. Empty layout returned.";
                         return QVector<QPointF>();
                     }
                 }
                 return QPointF(x, y);
             }
-            bool LogXLogYDomain::attachAxis(QAbstractAxis* axis)
+            bool LogXLogYDomain::attachAxis(QAbstractAxis *axis)
             {
                 AbstractDomain::attachAxis(axis);
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
-                if(logAxis && logAxis->orientation()==Qt::Vertical) {
+                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) {
+                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)
+            bool LogXLogYDomain::detachAxis(QAbstractAxis *axis)
             {
                 AbstractDomain::detachAxis(axis);
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
-                if(logAxis && logAxis->orientation()==Qt::Vertical)
+                if (logAxis && logAxis->orientation() == Qt::Vertical)
                     QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
-                if(logAxis && logAxis->orientation()==Qt::Horizontal)
+                if (logAxis && logAxis->orientation() == Qt::Horizontal)
                     QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
                 return true;
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const LogXLogYDomain &domain1, const LogXLogYDomain &domain2)
             {
-                return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
+                return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX)
-                        qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
+                        && qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY)
-                        qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
+                        && qFuzzyIsNull(domain1.m_minX - domain2.m_minX)
-                        qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
+                        && qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
             }

src/domain/logxlogydomain_p.h +3 -3

                 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 QList<QPointF> &vector) const;
-                bool attachAxis(QAbstractAxis* axis);
+                bool attachAxis(QAbstractAxis *axis);
-                bool detachAxis(QAbstractAxis* axis);
+                bool detachAxis(QAbstractAxis *axis);
             public Q_SLOTS:
                 void handleVerticalAxisBaseChanged(qreal baseY);

src/domain/logxydomain.cpp +14 -12

                 bool axisXChanged = false;
                 bool axisYChanged = false;
+                adjustLogDomainRanges(minX, maxX);
                 if (!qFuzzyCompare(m_minX, minX) || !qFuzzyCompare(m_maxX, maxX)) {
                     m_minX = minX;
                     m_maxX = maxX;
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
-                    if(!m_signalsBlocked)
+                    if (!m_signalsBlocked)
                         emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                     ok = true;
                     return QPointF(x, y);
                 } else {
-                    qWarning() << "Logarithm of negative value is undefined. Empty layout returned";
+                    qWarning() << "Logarithm of negative value is undefined. Empty layout returned.";
                     ok = false;
                     return QPointF();
                 }
             }
-            QVector<QPointF> LogXYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
+            QVector<QPointF> LogXYDomain::calculateGeometryPoints(const QList<QPointF> &vector) const
             {
                 const qreal deltaX = m_size.width() / (m_logRightX - m_logLeftX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                         result[i].setX(x);
                         result[i].setY(y);
                     } else {
-                        qWarning() << "Logarithm of negative value is undefined. Empty layout returned";
+                        qWarning() << "Logarithm of negative value is undefined. Empty layout returned.";
                         return QVector<QPointF>();
                     }
                 }
                 return QPointF(x, y);
             }
-            bool LogXYDomain::attachAxis(QAbstractAxis* axis)
+            bool LogXYDomain::attachAxis(QAbstractAxis *axis)
             {
                 AbstractDomain::attachAxis(axis);
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
-                if(logAxis && logAxis->orientation()==Qt::Horizontal) {
+                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)
+            bool LogXYDomain::detachAxis(QAbstractAxis *axis)
             {
                 AbstractDomain::detachAxis(axis);
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
-                if(logAxis && logAxis->orientation()==Qt::Horizontal)
+                if (logAxis && logAxis->orientation() == Qt::Horizontal)
                     QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
                 return true;
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const LogXYDomain &domain1, const LogXYDomain &domain2)
             {
-                return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
+                return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX)
-                        qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
+                        && qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY)
-                        qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
+                        && qFuzzyIsNull(domain1.m_minX - domain2.m_minX)
-                        qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
+                        && qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
             }

src/domain/logxydomain_p.h +3 -3

                 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 QList<QPointF> &vector) const;
-                bool attachAxis(QAbstractAxis* axis);
+                bool attachAxis(QAbstractAxis *axis);
-                bool detachAxis(QAbstractAxis* axis);
+                bool detachAxis(QAbstractAxis *axis);
             public Q_SLOTS:
                 void handleHorizontalAxisBaseChanged(qreal baseX);

src/domain/xlogydomain.cpp +14 -12

                 bool axisXChanged = false;
                 bool axisYChanged = false;
+                adjustLogDomainRanges(minY, maxY);
                 if (!qFuzzyIsNull(m_minX - minX) || !qFuzzyIsNull(m_maxX - maxX)) {
                     m_minX = minX;
                     m_maxX = maxX;
                     qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
                     m_logLeftY = logMinY < logMaxY ? logMinY : logMaxY;
                     m_logRightY = logMinY > logMaxY ? logMinY : logMaxY;
-                    if(!m_signalsBlocked)
+                    if (!m_signalsBlocked)
                         emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                     ok = true;
                     return QPointF(x, y);
                 } else {
-                    qWarning() << "Logarithm of negative value is undefined. Empty layout returned";
+                    qWarning() << "Logarithm of negative value is undefined. Empty layout returned.";
                     ok = false;
                     return QPointF();
                 }
             }
-            QVector<QPointF> XLogYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
+            QVector<QPointF> XLogYDomain::calculateGeometryPoints(const QList<QPointF> &vector) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / qAbs(m_logRightY - m_logLeftY);
                         result[i].setX(x);
                         result[i].setY(y);
                     } else {
-                        qWarning() << "Logarithm of negative value is undefined. Empty layout returned";
+                        qWarning() << "Logarithm of negative value is undefined. Empty layout returned.";
                         return QVector<QPointF>();
                     }
                 }
                 return QPointF(x, y);
             }
-            bool XLogYDomain::attachAxis(QAbstractAxis* axis)
+            bool XLogYDomain::attachAxis(QAbstractAxis *axis)
             {
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
-                if(logAxis && logAxis->orientation()==Qt::Vertical){
+                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)
+            bool XLogYDomain::detachAxis(QAbstractAxis *axis)
             {
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
-                if(logAxis && logAxis->orientation()==Qt::Vertical)
+                if (logAxis && logAxis->orientation() == Qt::Vertical)
                     QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
                 return AbstractDomain::detachAxis(axis);
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const XLogYDomain &domain1, const XLogYDomain &domain2)
             {
-                return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
+                return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX)
-                        qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
+                        && qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY)
-                        qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
+                        && qFuzzyIsNull(domain1.m_minX - domain2.m_minX)
-                        qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
+                        && qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
             }

src/domain/xlogydomain_p.h +3 -3

                 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 QList<QPointF> &vector) const;
-                bool attachAxis(QAbstractAxis* axis);
+                bool attachAxis(QAbstractAxis *axis);
-                bool detachAxis(QAbstractAxis* axis);
+                bool detachAxis(QAbstractAxis *axis);
             public Q_SLOTS:
                 void handleVerticalAxisBaseChanged(qreal baseY);

src/domain/xydomain.cpp +5 -5

                 return QPointF(x, y);
             }
-            QVector<QPointF> XYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
+            QVector<QPointF> XYDomain::calculateGeometryPoints(const QList<QPointF> &vector) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const XYDomain &domain1, const XYDomain &domain2)
             {
-                return (qFuzzyCompare(domain1.m_maxX, domain2.m_maxX) &&
+                return (qFuzzyCompare(domain1.m_maxX, domain2.m_maxX)
-                        qFuzzyCompare(domain1.m_maxY, domain2.m_maxY) &&
+                        && qFuzzyCompare(domain1.m_maxY, domain2.m_maxY)
-                        qFuzzyCompare(domain1.m_minX, domain2.m_minX) &&
+                        && qFuzzyCompare(domain1.m_minX, domain2.m_minX)
-                        qFuzzyCompare(domain1.m_minY, domain2.m_minY));
+                        && qFuzzyCompare(domain1.m_minY, domain2.m_minY));
             }

src/domain/xydomain_p.h +1 -1

                 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 QList<QPointF> &vector) const;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/layout/abstractchartlayout_p.h ~~src/chartlayout_p.h~~ renamed +24 -25

             //
             // We mean it.
-            #ifndef CHARTLAYOUT_H
+            #ifndef ABSTRACTCHARTLAYOUT_H
-            #define CHARTLAYOUT_H
+            #define ABSTRACTCHARTLAYOUT_H
             #include <QGraphicsLayout>
             #include <QMargins>
             #include "qchartglobal.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class ChartPresenter;
             class ChartTitle;
+            class ChartAxisElement;
+            class ChartPresenter;
             class QLegend;
-            class ChartAxis;
             class ChartBackground;
-            class ChartLayout : public QGraphicsLayout
+            class AbstractChartLayout : public QGraphicsLayout
             {
             public:
+                AbstractChartLayout(ChartPresenter *presenter);
+                virtual ~AbstractChartLayout();
-                ChartLayout(ChartPresenter *presenter);
+                virtual void setMargins(const QMargins &margins);
-                virtual ~ChartLayout();
+                virtual QMargins margins() const;
+                virtual void setGeometry(const QRectF &rect);
-                void setMargins(const QMargins &margins);
+            protected:
-                QMargins margins() const;
+                virtual QRectF calculateBackgroundGeometry(const QRectF &geometry, ChartBackground *background) const;
+                virtual QRectF calculateBackgroundMinimum(const QRectF &minimum) const;
+                virtual QRectF calculateContentGeometry(const QRectF &geometry) const;
+                virtual QRectF calculateContentMinimum(const QRectF &minimum) const;
+                virtual QRectF calculateTitleGeometry(const QRectF &geometry, ChartTitle *title) const;
+                virtual QRectF calculateTitleMinimum(const QRectF &minimum, ChartTitle *title) const;
+                virtual QRectF calculateLegendGeometry(const QRectF &geometry, QLegend *legend) const;
+                virtual QRectF calculateLegendMinimum(const QRectF &minimum, QLegend *legend) const;
-                void setGeometry(const QRectF &rect);
+                virtual QRectF calculateAxisGeometry(const QRectF &geometry, const QList<ChartAxisElement *>& axes) const = 0;
+                virtual QRectF calculateAxisMinimum(const QRectF &minimum, const QList<ChartAxisElement *>& axes) const = 0;
-            protected:
+                // from QGraphicsLayout
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
                 int count() const { return 0; }
                 QGraphicsLayoutItem *itemAt(int) const { return 0; };
                 void removeAt(int) {};
-            private:
-                QRectF calculateBackgroundGeometry(const QRectF &geometry, ChartBackground *background) const;
-                QRectF calculateContentGeometry(const QRectF &geometry) const;
-                QRectF calculateTitleGeometry(const QRectF &geometry, ChartTitle *title) const;
-                QRectF calculateLegendGeometry(const QRectF &geometry, QLegend *legend) const;
-                QRectF calculateAxisGeometry(const QRectF &geometry, const QList<ChartAxis *>& axes) const;
-                QRectF calculateBackgroundMinimum(const QRectF &minimum) const;
-                QRectF calculateContentMinimum(const QRectF &minimum) const;
-                QRectF calculateTitleMinimum(const QRectF &minimum, ChartTitle *title) const;
-                QRectF calculateAxisMinimum(const QRectF &minimum, const QList<ChartAxis *>& axes) const;
-                QRectF calculateLegendMinimum(const QRectF &minimum, QLegend *legend) const;
-            private:
                 ChartPresenter *m_presenter;
                 QMargins m_margins;
                 QRectF m_minChartRect;
             QTCOMMERCIALCHART_END_NAMESPACE
-            #endif
+            #endif // ABSTRACTCHARTLAYOUT_H

src/layout/cartesianchartlayout.cpp ~~src/chartlayout.cpp~~ renamed +16 -172

@@ -18,88 +18,25
18	**	18	**
19	****************************************************************************/	19	****************************************************************************/
20		20
21	#include "chartlayout_p.h"	21	#include "cartesianchartlayout_p.h"
22	#include "chartpresenter_p.h"	22	#include "chartpresenter_p.h"
23	#include "~~qlegend~~_p.h"	23	#include "chartaxiselement_p.h"
24	#include "chartaxis_p.h"
25	#include "charttitle_p.h"
26	#include "chartbackground_p.h"
27	#include <QDebug>	24	#include <QDebug>
28		25
29	QTCOMMERCIALCHART_BEGIN_NAMESPACE	26	QTCOMMERCIALCHART_BEGIN_NAMESPACE
30		27
31	static const qreal maxAxisPortion = 0.4;	28	static const qreal maxAxisPortion = 0.4;
32		29
33	ChartLayout::ChartLayout(ChartPresenter *presenter)	30	CartesianChartLayout::CartesianChartLayout(ChartPresenter *presenter)
34	: ~~m_presenter~~(presenter),	31	: AbstractChartLayout(presenter)
35	m_margins(20, 20, 20, 20),
36	m_minChartRect(0, 0, 200, 200)
37	{	32	{
38
39	}
40
41	ChartLayout::~ChartLayout()
42	{
43
44	}
45
46	void ChartLayout::setGeometry(const QRectF &rect)
47	{
48	if (!rect.isValid())
49	return;
50
51	QList<ChartAxis *> axes = m_presenter->axisItems();
52	ChartTitle *title = m_presenter->titleElement();
53	QLegend *legend = m_presenter->legend();
54	ChartBackground *background = m_presenter->backgroundElement();
55
56	QRectF contentGeometry = calculateBackgroundGeometry(rect, background);
57
58	contentGeometry = calculateContentGeometry(contentGeometry);
59
60	if (title && title->isVisible())
61	contentGeometry = calculateTitleGeometry(contentGeometry, title);
62
63	if (legend->isAttachedToChart() && legend->isVisible())
64	contentGeometry = calculateLegendGeometry(contentGeometry, legend);
65
66	contentGeometry = calculateAxisGeometry(contentGeometry, axes);
67
68	m_presenter->setGeometry(contentGeometry);
69
70	QGraphicsLayout::setGeometry(rect);
71	}	33	}
72		34
73	QRectF ChartLayout::calculateContentGeometry(const QRectF &geometry) const	35	CartesianChartLayout::~CartesianChartLayout()
74	{	36	{
75	return geometry.adjusted(m_margins.left(), m_margins.top(), -m_margins.right(), -m_margins.bottom());
76	}	37	}
77		38
78	QRectF ChartLayout::calculateContentMinimum(const QRectF &minimum) const	39	QRectF CartesianChartLayout::calculateAxisGeometry(const QRectF &geometry, const QList<ChartAxisElement *> &axes) const
79	{
80	return minimum.adjusted(0, 0, m_margins.left() + m_margins.right(), m_margins.top() + m_margins.bottom());
81	}
82
83
84	QRectF ChartLayout::calculateBackgroundGeometry(const QRectF &geometry, ChartBackground *background) const
85	{
86	qreal left, top, right, bottom;
87	getContentsMargins(&left, &top, &right, &bottom);
88	QRectF backgroundGeometry = geometry.adjusted(left, top, -right, -bottom);
89	if (background)
90	background->setRect(backgroundGeometry);
91	return backgroundGeometry;
92	}
93
94	QRectF ChartLayout::calculateBackgroundMinimum(const QRectF &minimum) const
95	{
96	qreal left, top, right, bottom;
97	getContentsMargins(&left, &top, &right, &bottom);
98	return minimum.adjusted(0, 0, left + right, top + bottom);
99	}
100
101
102	QRectF ChartLayout::calculateAxisGeometry(const QRectF &geometry, const QList<ChartAxis *>& axes) const
103	{	40	{
104	QSizeF left(0,0);	41	QSizeF left(0,0);
105	QSizeF minLeft(0,0);	42	QSizeF minLeft(0,0);
@@ -115,16 +52,17 QRectF ChartLayout::calculateAxisGeometry(const QRectF &geometry, const QList<Ch
115	int topCount = 0;	52	int topCount = 0;
116	int bottomCount = 0;	53	int bottomCount = 0;
117		54
118	foreach (ChartAxis *axis , axes) {	55	foreach (ChartAxisElement *axis , axes) {
119		56
120	if (!axis->isVisible())	57	if (!axis->isVisible())
121	continue;	58	continue;
122		59
		60
123	QSizeF size = axis->effectiveSizeHint(Qt::PreferredSize);	61	QSizeF size = axis->effectiveSizeHint(Qt::PreferredSize);
124	//this is used to get single thick font size	62	//this is used to get single thick font size
125	QSizeF minSize = axis->effectiveSizeHint(Qt::MinimumSize);	63	QSizeF minSize = axis->effectiveSizeHint(Qt::MinimumSize);
126		64
127	switch (axis->alignment()) {	65	switch (axis->axis()->alignment()) {
128	case Qt::AlignLeft:	66	case Qt::AlignLeft:
129	left.setWidth(left.width()+size.width());	67	left.setWidth(left.width()+size.width());
130	left.setHeight(qMax(left.height(),size.height()));	68	left.setHeight(qMax(left.height(),size.height()));
@@ -163,7 +101,7 QRectF ChartLayout::calculateAxisGeometry(const QRectF &geometry, const QList<Ch
163	}	101	}
164	}	102	}
165		103
166	~~int~~ totalVerticalAxes = leftCount + rightCount;	104	qreal totalVerticalAxes = leftCount + rightCount;
167	qreal leftSqueezeRatio = 1.0;	105	qreal leftSqueezeRatio = 1.0;
168	qreal rightSqueezeRatio = 1.0;	106	qreal rightSqueezeRatio = 1.0;
169	qreal vratio = 0;	107	qreal vratio = 0;
@@ -186,7 +124,7 QRectF ChartLayout::calculateAxisGeometry(const QRectF &geometry, const QList<Ch
186	}	124	}
187	}	125	}
188		126
189	~~int~~ totalHorizontalAxes = topCount + bottomCount;	127	qreal totalHorizontalAxes = topCount + bottomCount;
190	qreal topSqueezeRatio = 1.0;	128	qreal topSqueezeRatio = 1.0;
191	qreal bottomSqueezeRatio = 1.0;	129	qreal bottomSqueezeRatio = 1.0;
192	qreal hratio = 0;	130	qreal hratio = 0;
@@ -225,15 +163,14 QRectF ChartLayout::calculateAxisGeometry(const QRectF &geometry, const QList<Ch
225	qreal topOffset = 0;	163	qreal topOffset = 0;
226	qreal bottomOffset = 0;	164	qreal bottomOffset = 0;
227		165
228	foreach(ChartElement *axis~~Element~~ , axes) {	166	foreach (ChartAxisElement *axis , axes) {
229	ChartAxis* axis = qobject_cast<ChartAxis*>(axisElement);
230		167
231	if (!axis->isVisible())	168	if (!axis->isVisible())
232	continue;	169	continue;
233		170
234	QSizeF size = axis->effectiveSizeHint(Qt::PreferredSize);	171	QSizeF size = axis->effectiveSizeHint(Qt::PreferredSize);
235		172
236	switch(axis->alignment()){	173	switch (axis->axis()->alignment()){
237	case Qt::AlignLeft:{	174	case Qt::AlignLeft:{
238	qreal width = size.width();	175	qreal width = size.width();
239	if (leftSqueezeRatio < 1.0)	176	if (leftSqueezeRatio < 1.0)
@@ -271,21 +208,20 QRectF ChartLayout::calculateAxisGeometry(const QRectF &geometry, const QList<Ch
271	return chartRect;	208	return chartRect;
272	}	209	}
273		210
274	QRectF ChartLayout::calculateAxisMinimum(const QRectF &minimum, const QList<ChartAxis *>& axes) const	211	QRectF CartesianChartLayout::calculateAxisMinimum(const QRectF &minimum, const QList<ChartAxisElement *> &axes) const
275	{	212	{
276	QSizeF left;	213	QSizeF left;
277	QSizeF right;	214	QSizeF right;
278	QSizeF bottom;	215	QSizeF bottom;
279	QSizeF top;	216	QSizeF top;
280		217
281	foreach (ChartAxis *axis, axes) {	218	foreach (ChartAxisElement *axis, axes) {
282
283	QSizeF size = axis->effectiveSizeHint(Qt::MinimumSize);	219	QSizeF size = axis->effectiveSizeHint(Qt::MinimumSize);
284		220
285	if (!axis->isVisible())	221	if (!axis->isVisible())
286	continue;	222	continue;
287		223
288	switch (axis->alignment()) {	224	switch (axis->axis()->alignment()) {
289	case Qt::AlignLeft:	225	case Qt::AlignLeft:
290	left.setWidth(left.width() + size.width());	226	left.setWidth(left.width() + size.width());
291	left.setHeight(qMax(left.height() * 2, size.height()));	227	left.setHeight(qMax(left.height() * 2, size.height()));
@@ -307,96 +243,4 QRectF ChartLayout::calculateAxisMinimum(const QRectF &minimum, const QList<Char
307	return minimum.adjusted(0, 0, left.width() + right.width() + qMax(top.width(), bottom.width()), top.height() + bottom.height() + qMax(left.height(), right.height()));	243	return minimum.adjusted(0, 0, left.width() + right.width() + qMax(top.width(), bottom.width()), top.height() + bottom.height() + qMax(left.height(), right.height()));
308	}	244	}
309		245
310	QRectF ChartLayout::calculateLegendGeometry(const QRectF &geometry, QLegend *legend) const
311	{
312	QSizeF size = legend->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, -1));
313	QRectF legendRect;
314	QRectF result;
315
316	switch (legend->alignment()) {
317	case Qt::AlignTop: {
318	legendRect = QRectF(geometry.topLeft(), QSizeF(geometry.width(), size.height()));
319	result = geometry.adjusted(0, legendRect.height(), 0, 0);
320	break;
321	}
322	case Qt::AlignBottom: {
323	legendRect = QRectF(QPointF(geometry.left(), geometry.bottom() - size.height()), QSizeF(geometry.width(), size.height()));
324	result = geometry.adjusted(0, 0, 0, -legendRect.height());
325	break;
326	}
327	case Qt::AlignLeft: {
328	qreal width = qMin(size.width(), geometry.width() * maxAxisPortion);
329	legendRect = QRectF(geometry.topLeft(), QSizeF(width, geometry.height()));
330	result = geometry.adjusted(width, 0, 0, 0);
331	break;
332	}
333	case Qt::AlignRight: {
334	qreal width = qMin(size.width(), geometry.width() * maxAxisPortion);
335	legendRect = QRectF(QPointF(geometry.right() - width, geometry.top()), QSizeF(width, geometry.height()));
336	result = geometry.adjusted(0, 0, -width, 0);
337	break;
338	}
339	default: {
340	legendRect = QRectF(0, 0, 0, 0);
341	result = geometry;
342	break;
343	}
344	}
345
346	legend->setGeometry(legendRect);
347
348	return result;
349	}
350
351	QRectF ChartLayout::calculateLegendMinimum(const QRectF &geometry, QLegend *legend) const
352	{
353	QSizeF minSize = legend->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, -1));
354	return geometry.adjusted(0, 0, minSize.width(), minSize.height());
355	}
356
357	QRectF ChartLayout::calculateTitleGeometry(const QRectF &geometry, ChartTitle *title) const
358	{
359	title->setGeometry(geometry);
360	QPointF center = geometry.center() - title->boundingRect().center();
361	title->setPos(center.x(),title->pos().y());
362	return geometry.adjusted(0,title->boundingRect().height()+1,0,0);
363	}
364
365	QRectF ChartLayout::calculateTitleMinimum(const QRectF &minimum, ChartTitle *title) const
366	{
367	QSizeF min = title->sizeHint(Qt::MinimumSize);
368	return minimum.adjusted(0, 0, min.width(), min.height());
369	}
370
371	QSizeF ChartLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
372	{
373	Q_UNUSED(constraint);
374	if (which == Qt::MinimumSize) {
375	QList<ChartAxis *> axes = m_presenter->axisItems();
376	ChartTitle *title = m_presenter->titleElement();
377	QLegend *legend = m_presenter->legend();
378	QRectF minimumRect(0, 0, 0, 0);
379	minimumRect = calculateBackgroundMinimum(minimumRect);
380	minimumRect = calculateContentMinimum(minimumRect);
381	minimumRect = calculateTitleMinimum(minimumRect, title);
382	minimumRect = calculateLegendMinimum(minimumRect, legend);
383	minimumRect = calculateAxisMinimum(minimumRect, axes);
384	return minimumRect.united(m_minChartRect).size().toSize();
385	}
386	return QSize(-1, -1);
387	}
388
389	void ChartLayout::setMargins(const QMargins &margins)
390	{
391	if (m_margins != margins) {
392	m_margins = margins;
393	updateGeometry();
394	}
395	}
396
397	QMargins ChartLayout::margins() const
398	{
399	return m_margins;
400	}
401
402	QTCOMMERCIALCHART_END_NAMESPACE	246	QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendlayout.cpp +1 -1

             #include "legendlayout_p.h"
             #include "chartpresenter_p.h"
             #include "qlegend_p.h"
-            #include "chartlayout_p.h"
+            #include "abstractchartlayout_p.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"

src/legend/qlegend.cpp +1 -1

             #include "qchart_p.h"
             #include "legendlayout_p.h"
             #include "chartpresenter_p.h"
-            #include "chartlayout_p.h"
+            #include "abstractchartlayout_p.h"
             #include "qlegendmarker.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"

src/linechart/linechartitem.cpp +225 -24

@@ -22,7 +22,7
22	#include "qlineseries.h"	22	#include "qlineseries.h"
23	#include "qlineseries_p.h"	23	#include "qlineseries_p.h"
24	#include "chartpresenter_p.h"	24	#include "chartpresenter_p.h"
25	#include "a~~bst~~r~~act~~domain_p.h"	25	#include "polardomain_p.h"
26	#include <QPainter>	26	#include <QPainter>
27	#include <QGraphicsSceneMouseEvent>	27	#include <QGraphicsSceneMouseEvent>
28		28
@@ -30,10 +30,11 QTCOMMERCIALCHART_BEGIN_NAMESPACE
30		30
31	const qreal mouseEventMinWidth(12);	31	const qreal mouseEventMinWidth(12);
32		32
33	LineChartItem::LineChartItem(QLineSeries series,QGraphicsItem item)	33	LineChartItem::LineChartItem(QLineSeries series, QGraphicsItem item)
34	: XYChart(series,item),	34	: XYChart(series,item),
35	m_series(series),	35	m_series(series),
36	m_pointsVisible(false)	36	m_pointsVisible(false),
		37	m_chartType(QChart::ChartTypeUndefined)
37	{	38	{
38	setAcceptHoverEvents(true);	39	setAcceptHoverEvents(true);
39	setZValue(ChartPresenter::LineChartZValue);	40	setZValue(ChartPresenter::LineChartZValue);
@@ -50,54 +51,235 QRectF LineChartItem::boundingRect() const
50		51
51	QPainterPath LineChartItem::shape() const	52	QPainterPath LineChartItem::shape() const
52	{	53	{
53	return m_path;	54	return m_shapePath;
54	}	55	}
55		56
56	void LineChartItem::updateGeometry()	57	void LineChartItem::updateGeometry()
57	{	58	{
58	m_points = geometryPoints();	59	m_points = geometryPoints();
		60	const QVector<QPointF> &points = m_points;
59		61
60	if (m_points.size() == 0) {	62	if (points.size() == 0) {
61	prepareGeometryChange();	63	prepareGeometryChange();
62	m_path = QPainterPath();	64	m_fullPath = QPainterPath();
63	m_linePath = QPainterPath();	65	m_linePath = QPainterPath();
64	m_rect = QRect();	66	m_rect = QRect();
65	return;	67	return;
66	}	68	}
67		69
68	QPainterPath linePath(~~m_points~~.at(0));	70	QPainterPath linePath;
		71	QPainterPath fullPath;
		72	// Use worst case scenario to determine required margin.
		73	qreal margin = m_linePen.width() * 1.42;
69		74
70	if (m_pointsVisible) {	75	// Area series use component line series that aren't necessarily added to the chart themselves,
		76	// so check if chart type is forced before trying to obtain it from the chart.
		77	QChart::ChartType chartType = m_chartType;
		78	if (chartType == QChart::ChartTypeUndefined)
		79	chartType = m_series->chart()->chartType();
71		80
		81	// For polar charts, we need special handling for angular (horizontal)
		82	// points that are off-grid.
		83	if (chartType == QChart::ChartTypePolar) {
		84	QPainterPath linePathLeft;
		85	QPainterPath linePathRight;
		86	QPainterPath *currentSegmentPath = 0;
		87	QPainterPath *previousSegmentPath = 0;
		88	qreal minX = domain()->minX();
		89	qreal maxX = domain()->maxX();
		90	qreal minY = domain()->minY();
		91	QPointF currentSeriesPoint = m_series->pointAt(0);
		92	QPointF currentGeometryPoint = points.at(0);
		93	QPointF previousGeometryPoint = points.at(0);
72	int size = m_linePen.width();	94	int size = m_linePen.width();
73	linePath.addEllipse(m_points.at(0), size, size);	95	bool pointOffGrid = false;
74	linePath.moveTo(m_points.at(0));	96	bool previousPointWasOffGrid = (currentSeriesPoint.x() < minX \|\| currentSeriesPoint.x() > maxX);
75	for (int i = 1; i < m_points.size(); i++) {	97
76	linePath.lineTo(m_points.at(i));	98	qreal domainRadius = domain()->size().height() / 2.0;
77	linePath.addEllipse(m_points.at(i), size, size);	99	const QPointF centerPoint(domainRadius, domainRadius);
78	linePath.moveTo(m_points.at(i));	100
		101	if (!previousPointWasOffGrid) {
		102	fullPath.moveTo(points.at(0));
		103	if (m_pointsVisible && currentSeriesPoint.y() >= minY) {
		104	// Do not draw ellipses for points below minimum Y.
		105	linePath.addEllipse(points.at(0), size, size);
		106	fullPath.addEllipse(points.at(0), size, size);
		107	linePath.moveTo(points.at(0));
		108	fullPath.moveTo(points.at(0));
		109	}
79	}	110	}
80		111
81	} else {	112	qreal leftMarginLine = centerPoint.x() - margin;
82	for (int i = 1; i < m_points.size(); i++)	113	qreal rightMarginLine = centerPoint.x() + margin;
83	linePath.lineTo(m_points.at(i));	114	qreal horizontal = centerPoint.y();
84	}
85		115
86	m_linePath = linePath;	116	for (int i = 1; i < points.size(); i++) {
		117	// Interpolating line fragments would be ugly when thick pen is used,
		118	// so we work around it by utilizing three separate
		119	// paths for line segments and clip those with custom regions at paint time.
		120	// "Right" path contains segments that cross the axis line with visible point on the
		121	// right side of the axis line, as well as segments that have one point within the margin
		122	// on the right side of the axis line and another point on the right side of the chart.
		123	// "Left" path contains points with similarly on the left side.
		124	// "Full" path contains rest of the points.
		125	// This doesn't yield perfect results always. E.g. when segment covers more than 90
		126	// degrees and both of the points are within the margin, one in the top half and one in the
		127	// bottom half of the chart, the bottom one gets clipped incorrectly.
		128	// However, this should be rare occurrence in any sensible chart.
		129	currentSeriesPoint = m_series->pointAt(i);
		130	currentGeometryPoint = points.at(i);
		131	pointOffGrid = (currentSeriesPoint.x() < minX \|\| currentSeriesPoint.x() > maxX);
		132
		133	// Draw something unless both off-grid
		134	if (!pointOffGrid \|\| !previousPointWasOffGrid) {
		135	QPointF intersectionPoint;
		136	qreal y;
		137	if (pointOffGrid != previousPointWasOffGrid) {
		138	if (currentGeometryPoint.x() == previousGeometryPoint.x()) {
		139	y = currentGeometryPoint.y() + (currentGeometryPoint.y() - previousGeometryPoint.y()) / 2.0;
		140	} else {
		141	qreal ratio = (centerPoint.x() - currentGeometryPoint.x()) / (currentGeometryPoint.x() - previousGeometryPoint.x());
		142	y = currentGeometryPoint.y() + (currentGeometryPoint.y() - previousGeometryPoint.y()) * ratio;
		143	}
		144	intersectionPoint = QPointF(centerPoint.x(), y);
		145	}
		146
		147	bool dummyOk; // We know points are ok, but this is needed
		148	qreal currentAngle = static_cast<PolarDomain *>(domain())->toAngularCoordinate(currentSeriesPoint.x(), dummyOk);
		149	qreal previousAngle = static_cast<PolarDomain *>(domain())->toAngularCoordinate(m_series->pointAt(i - 1).x(), dummyOk);
		150
		151	if ((qAbs(currentAngle - previousAngle) > 180.0)) {
		152	// If the angle between two points is over 180 degrees (half X range),
		153	// any direct segment between them becomes meaningless.
		154	// In this case two line segments are drawn instead, from previous
		155	// point to the center and from center to current point.
		156	if ((previousAngle < 0.0 \|\| (previousAngle <= 180.0 && previousGeometryPoint.x() < rightMarginLine))
		157	&& previousGeometryPoint.y() < horizontal) {
		158	currentSegmentPath = &linePathRight;
		159	} else if ((previousAngle > 360.0 \|\| (previousAngle > 180.0 && previousGeometryPoint.x() > leftMarginLine))
		160	&& previousGeometryPoint.y() < horizontal) {
		161	currentSegmentPath = &linePathLeft;
		162	} else if (previousAngle > 0.0 && previousAngle < 360.0) {
		163	currentSegmentPath = &linePath;
		164	} else {
		165	currentSegmentPath = 0;
		166	}
		167
		168	if (currentSegmentPath) {
		169	if (previousSegmentPath != currentSegmentPath)
		170	currentSegmentPath->moveTo(previousGeometryPoint);
		171	if (previousPointWasOffGrid)
		172	fullPath.moveTo(intersectionPoint);
		173
		174	currentSegmentPath->lineTo(centerPoint);
		175	fullPath.lineTo(centerPoint);
		176	}
		177
		178	previousSegmentPath = currentSegmentPath;
		179
		180	if ((currentAngle < 0.0 \|\| (currentAngle <= 180.0 && currentGeometryPoint.x() < rightMarginLine))
		181	&& currentGeometryPoint.y() < horizontal) {
		182	currentSegmentPath = &linePathRight;
		183	} else if ((currentAngle > 360.0 \|\| (currentAngle > 180.0 &&currentGeometryPoint.x() > leftMarginLine))
		184	&& currentGeometryPoint.y() < horizontal) {
		185	currentSegmentPath = &linePathLeft;
		186	} else if (currentAngle > 0.0 && currentAngle < 360.0) {
		187	currentSegmentPath = &linePath;
		188	} else {
		189	currentSegmentPath = 0;
		190	}
		191
		192	if (currentSegmentPath) {
		193	if (previousSegmentPath != currentSegmentPath)
		194	currentSegmentPath->moveTo(centerPoint);
		195	if (!previousSegmentPath)
		196	fullPath.moveTo(centerPoint);
		197
		198	currentSegmentPath->lineTo(currentGeometryPoint);
		199	if (pointOffGrid)
		200	fullPath.lineTo(intersectionPoint);
		201	else
		202	fullPath.lineTo(currentGeometryPoint);
		203	}
		204	} else {
		205	if (previousAngle < 0.0 \|\| currentAngle < 0.0
		206	\|\| ((previousAngle <= 180.0 && currentAngle <= 180.0)
		207	&& ((previousGeometryPoint.x() < rightMarginLine && previousGeometryPoint.y() < horizontal)
		208	\|\| (currentGeometryPoint.x() < rightMarginLine && currentGeometryPoint.y() < horizontal)))) {
		209	currentSegmentPath = &linePathRight;
		210	} else if (previousAngle > 360.0 \|\| currentAngle > 360.0
		211	\|\| ((previousAngle > 180.0 && currentAngle > 180.0)
		212	&& ((previousGeometryPoint.x() > leftMarginLine && previousGeometryPoint.y() < horizontal)
		213	\|\| (currentGeometryPoint.x() > leftMarginLine && currentGeometryPoint.y() < horizontal)))) {
		214	currentSegmentPath = &linePathLeft;
		215	} else {
		216	currentSegmentPath = &linePath;
		217	}
		218
		219	if (currentSegmentPath != previousSegmentPath)
		220	currentSegmentPath->moveTo(previousGeometryPoint);
		221	if (previousPointWasOffGrid)
		222	fullPath.moveTo(intersectionPoint);
		223
		224	if (pointOffGrid)
		225	fullPath.lineTo(intersectionPoint);
		226	else
		227	fullPath.lineTo(currentGeometryPoint);
		228	currentSegmentPath->lineTo(currentGeometryPoint);
		229	}
		230	} else {
		231	currentSegmentPath = 0;
		232	}
		233
		234	previousPointWasOffGrid = pointOffGrid;
		235	if (m_pointsVisible && !pointOffGrid && currentSeriesPoint.y() >= minY) {
		236	linePath.addEllipse(points.at(i), size, size);
		237	fullPath.addEllipse(points.at(i), size, size);
		238	linePath.moveTo(points.at(i));
		239	fullPath.moveTo(points.at(i));
		240	}
		241	previousSegmentPath = currentSegmentPath;
		242	previousGeometryPoint = currentGeometryPoint;
		243	}
		244	m_linePathPolarRight = linePathRight;
		245	m_linePathPolarLeft = linePathLeft;
		246	// Note: This construction of m_fullpath is not perfect. The partial segments that are
		247	// outside left/right clip regions at axis boundary still generate hover/click events,
		248	// because shape doesn't get clipped. It doesn't seem possible to do sensibly.
		249	} else { // not polar
		250	linePath.moveTo(points.at(0));
		251	if (m_pointsVisible) {
		252	int size = m_linePen.width();
		253	linePath.addEllipse(points.at(0), size, size);
		254	linePath.moveTo(points.at(0));
		255	for (int i = 1; i < points.size(); i++) {
		256	linePath.lineTo(points.at(i));
		257	linePath.addEllipse(points.at(i), size, size);
		258	linePath.moveTo(points.at(i));
		259	}
		260	} else {
		261	for (int i = 1; i < points.size(); i++)
		262	linePath.lineTo(points.at(i));
		263	}
		264	fullPath = linePath;
		265	}
87		266
88	QPainterPathStroker stroker;	267	QPainterPathStroker stroker;
89	// QPainter::drawLine does not respect join styles, for example BevelJoin becomes MiterJoin.	268	// QPainter::drawLine does not respect join styles, for example BevelJoin becomes MiterJoin.
90	// This is why we are prepared for the "worst case" scenario, i.e. use always MiterJoin and	269	// This is why we are prepared for the "worst case" scenario, i.e. use always MiterJoin and
91	// multiply line width with square root of two when defining shape and bounding rectangle.	270	// multiply line width with square root of two when defining shape and bounding rectangle.
92	stroker.setWidth(m~~_linePen~~.~~width~~() * ~~1.42~~);	271	stroker.setWidth(margin);
93	stroker.setJoinStyle(Qt::MiterJoin);	272	stroker.setJoinStyle(Qt::MiterJoin);
94	stroker.setCapStyle(Qt::SquareCap);	273	stroker.setCapStyle(Qt::SquareCap);
95	stroker.setMiterLimit(m_linePen.miterLimit());	274	stroker.setMiterLimit(m_linePen.miterLimit());
96		275
97	prepareGeometryChange();	276	prepareGeometryChange();
98		277
99	m_path = stroker.createStroke(linePath);	278	m_linePath = linePath;
100	m_rect = m_path.boundingRect();	279	m_fullPath = fullPath;
		280	m_shapePath = stroker.createStroke(fullPath);
		281
		282	m_rect = m_shapePath.boundingRect();
101	}	283	}
102		284
103	void LineChartItem::handleUpdated()	285	void LineChartItem::handleUpdated()
@@ -121,16 +303,35 void LineChartItem::paint(QPainter painter, const QStyleOptionGraphicsItem opt
121	Q_UNUSED(widget)	303	Q_UNUSED(widget)
122	Q_UNUSED(option)	304	Q_UNUSED(option)
123		305
		306	QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
		307
124	painter->save();	308	painter->save();
125	painter->setPen(m_linePen);	309	painter->setPen(m_linePen);
126	painter->setClipRect(QRectF(QPointF(0,0),domain()->size()));	310	bool alwaysUsePath = false;
		311
		312	if (m_series->chart()->chartType() == QChart::ChartTypePolar) {
		313	qreal halfWidth = domain()->size().width() / 2.0;
		314	QRectF clipRectLeft = QRectF(0, 0, halfWidth, domain()->size().height());
		315	QRectF clipRectRight = QRectF(halfWidth, 0, halfWidth, domain()->size().height());
		316	QRegion fullPolarClipRegion(clipRect.toRect(), QRegion::Ellipse);
		317	QRegion clipRegionLeft(fullPolarClipRegion.intersected(clipRectLeft.toRect()));
		318	QRegion clipRegionRight(fullPolarClipRegion.intersected(clipRectRight.toRect()));
		319	painter->setClipRegion(clipRegionLeft);
		320	painter->drawPath(m_linePathPolarLeft);
		321	painter->setClipRegion(clipRegionRight);
		322	painter->drawPath(m_linePathPolarRight);
		323	painter->setClipRegion(fullPolarClipRegion);
		324	alwaysUsePath = true; // required for proper clipping
		325	} else {
		326	painter->setClipRect(clipRect);
		327	}
127		328
128	if (m_pointsVisible) {	329	if (m_pointsVisible) {
129	painter->setBrush(m_linePen.color());	330	painter->setBrush(m_linePen.color());
130	painter->drawPath(m_linePath);	331	painter->drawPath(m_linePath);
131	} else {	332	} else {
132	painter->setBrush(QBrush(Qt::NoBrush));	333	painter->setBrush(QBrush(Qt::NoBrush));
133	if (m_linePen.style() != Qt::SolidLine) {	334	if (m_linePen.style() != Qt::SolidLine \|\| alwaysUsePath) {
134	// If pen style is not solid line, always fall back to path painting	335	// If pen style is not solid line, always fall back to path painting
135	// to ensure proper continuity of the pattern	336	// to ensure proper continuity of the pattern
136	painter->drawPath(m_linePath);	337	painter->drawPath(m_linePath);

src/linechart/linechartitem_p.h +10 -3

             #include "qchartglobal.h"
             #include "xychart_p.h"
+            #include "qchart.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsItem)
             public:
-                explicit LineChartItem(QLineSeries *series, QGraphicsItem* item = 0);
+                explicit LineChartItem(QLineSeries *series, QGraphicsItem *item = 0);
                 ~LineChartItem() {}
                 //from QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
-                QPainterPath path() const { return m_linePath; }
+                QPainterPath path() const { return m_fullPath; }
             public Q_SLOTS:
                 void handleUpdated();
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
                 void suppressPoints() { m_pointsVisible = false; }
+                void forceChartType(QChart::ChartType chartType) { m_chartType = chartType; }
             private:
                 QLineSeries *m_series;
-                QPainterPath m_path;
                 QPainterPath m_linePath;
+                QPainterPath m_linePathPolarRight;
+                QPainterPath m_linePathPolarLeft;
+                QPainterPath m_fullPath;
+                QPainterPath m_shapePath;
                 QVector<QPointF> m_points;
                 QRectF m_rect;
                 QPen m_linePen;
                 bool m_pointsVisible;
+                QChart::ChartType m_chartType;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.cpp +59 -12

             #include "qlegend_p.h"
             #include "chartbackground_p.h"
             #include "qabstractaxis.h"
-            #include "chartlayout_p.h"
+            #include "abstractchartlayout_p.h"
             #include "charttheme_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
              */
             /*!
+             \enum QChart::ChartType
+             This enum describes the chart type.
+             \value ChartTypeUndefined
+             \value ChartTypeCartesian
+             \value ChartTypePolar
+             */
+            /*!
              \class QChart
              \brief QtCommercial chart API.
              */
             /*!
-             Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
+             \property QChart::chartType
+             Chart type indicates if the chart is a cartesian chart or a polar chart.
+             This property is set internally and is read only.
+             \sa QPolarChart
+             */
+            /*!
+             \internal
+             Constructs a chart object of \a type which is a child of a \a parent.
+             Parameter \a wFlags is passed to the QGraphicsWidget constructor.
+             This constructor is called only by subclasses.
+            */
+            QChart::QChart(QChart::ChartType type, QGraphicsItem *parent, Qt::WindowFlags wFlags)
+                : QGraphicsWidget(parent, wFlags),
+                  d_ptr(new QChartPrivate(this, type))
+            {
+                d_ptr->init();
+            }
+            /*!
+             Constructs a chart object which is a child of a \a parent.
+             Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 : QGraphicsWidget(parent, wFlags),
-                  d_ptr(new QChartPrivate(this))
+                  d_ptr(new QChartPrivate(this, ChartTypeCartesian))
             {
-                d_ptr->m_legend = new LegendScroller(this);
+                d_ptr->init();
-                setTheme(QChart::ChartThemeLight);
-                setLayout(d_ptr->m_presenter->layout());
             }
             /*!
             /*!
              Zooms in the view to a maximum level at which \a rect is still fully visible.
+             \note This is not supported for polar charts.
              */
             void QChart::zoomIn(const QRectF &rect)
             {
+                if (d_ptr->m_type == QChart::ChartTypePolar)
+                    return;
                 d_ptr->zoomIn(rect);
             }
             }
             /*!
-             Returns the pointer to the x axis object of the chart asociated with the specified \a series
+             Returns the pointer to the x axis object of the chart associated with the specified \a series.
-             If no series is provided then pointer to currently visible axis is provided
+             If no series is provided then pointer to currently visible axis is provided.
              */
             QAbstractAxis *QChart::axisX(QAbstractSeries *series) const
             {
             }
             /*!
-             Returns the pointer to the y axis object of the chart asociated with the specified \a series
+             Returns the pointer to the y axis object of the chart associated with the specified \a series.
-             If no series is provided then pointer to currently visible axis is provided
+             If no series is provided then pointer to currently visible axis is provided.
              */
             QAbstractAxis *QChart::axisY(QAbstractSeries *series) const
             {
                 return d_ptr->m_presenter->layout()->margins();
             }
+            QChart::ChartType QChart::chartType() const
+            {
+                return d_ptr->m_type;
+            }
             /*!
                 Returns the the rect within which the drawing of the chart is done.
                 It does not include the area defines by margins.
             /*!
                 Scrolls the visible area of the chart by the distance defined in the \a dx and \a dy.
+                For polar charts, \a dx indicates the angle along angular axis instead of distance.
              */
             void QChart::scroll(qreal dx, qreal dy)
             {
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QChartPrivate::QChartPrivate(QChart *q):
+            QChartPrivate::QChartPrivate(QChart *q, QChart::ChartType type):
                 q_ptr(q),
+                m_type(type),
                 m_legend(0),
                 m_dataset(new ChartDataSet(q)),
-                m_presenter(new ChartPresenter(q)),
+                m_presenter(new ChartPresenter(q, type)),
                 m_themeManager(new ChartThemeManager(q))
             {
                 QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), m_presenter, SLOT(handleSeriesAdded(QAbstractSeries*)));
             }
+            void QChartPrivate::init()
+            {
+                m_legend = new LegendScroller(q_ptr);
+                q_ptr->setTheme(QChart::ChartThemeLight);
+                q_ptr->setLayout(m_presenter->layout());
+            }
             void QChartPrivate::zoomIn(qreal factor)
             {
                 QRectF rect = m_presenter->geometry();

src/qchart.h +12 -1

                 Q_PROPERTY(QChart::AnimationOptions animationOptions READ animationOptions WRITE setAnimationOptions)
                 Q_PROPERTY(QMargins minimumMargins READ minimumMargins WRITE setMinimumMargins)
                 Q_PROPERTY(QMargins margins READ margins WRITE setMargins)
+                Q_PROPERTY(QChart::ChartType chartType READ chartType)
                 Q_ENUMS(ChartTheme)
                 Q_ENUMS(AnimationOption)
+                Q_ENUMS(ChartType)
             public:
+                enum ChartType {
+                    ChartTypeUndefined = 0,
+                    ChartTypeCartesian,
+                    ChartTypePolar
+                };
                 enum ChartTheme {
                     ChartThemeLight = 0,
                     ChartThemeBlueCerulean,
                 QAbstractAxis *axisY(QAbstractSeries *series = 0) const;
                 // ******************
-                void addAxis(QAbstractAxis *axis,Qt::Alignment alignment);
+                void addAxis(QAbstractAxis *axis, Qt::Alignment alignment);
                 void removeAxis(QAbstractAxis *axis);
                 QList<QAbstractAxis*> axes(Qt::Orientations orientation = Qt::Horizontal|Qt::Vertical, QAbstractSeries *series = 0) const;
                 QPointF mapToValue(const QPointF &position, QAbstractSeries *series = 0);
                 QPointF mapToPosition(const QPointF &value, QAbstractSeries *series = 0);
+                ChartType chartType() const;
             protected:
+                explicit QChart(QChart::ChartType type, QGraphicsItem *parent, Qt::WindowFlags wFlags);
                 QScopedPointer<QChartPrivate> d_ptr;
                 friend class QLegend;
                 friend class DeclarativeChart;

src/qchart_p.h +4 -2

             #define QCHART_P_H
             #include "qchartglobal.h"
+            #include "qchart.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QChart;
             class ChartThemeManager;
             class ChartPresenter;
             class QLegend;
             {
             public:
-                QChartPrivate(QChart *q);
+                QChartPrivate(QChart *q, QChart::ChartType type);
                 ~QChartPrivate();
                 QChart *q_ptr;
                 QLegend *m_legend;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;
                 ChartThemeManager *m_themeManager;
+                QChart::ChartType m_type;
+                void init();
                 void zoomIn(qreal factor);
                 void zoomOut(qreal factor);
                 void zoomIn(const QRectF &rect);

src/scatterchart/scatterchartitem.cpp +9 -5

             #include "qscatterseries_p.h"
             #include "chartpresenter_p.h"
             #include "abstractdomain_p.h"
+            #include "qchart.h"
             #include <QPainter>
             #include <QGraphicsScene>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ScatterChartItem::ScatterChartItem(QScatterSeries *series, QGraphicsItem* item)
+            ScatterChartItem::ScatterChartItem(QScatterSeries *series, QGraphicsItem *item)
                 : XYChart(series,item),
                   m_series(series),
                   m_items(this),
             void ScatterChartItem::markerSelected(QGraphicsItem *marker)
             {
-                emit XYChart::clicked(domain()->calculateDomainPoint(m_markerMap[marker]));
+                emit XYChart::clicked(m_markerMap[marker]);
             }
             void ScatterChartItem::markerHovered(QGraphicsItem *marker, bool state)
             {
-                emit XYChart::hovered(domain()->calculateDomainPoint(m_markerMap[marker]), state);
+                emit XYChart::hovered(m_markerMap[marker], state);
             }
             void ScatterChartItem::updateGeometry()
                 QRectF clipRect(QPointF(0,0),domain()->size());
+                QVector<bool> offGridStatus = offGridStatusVector();
                 for (int i = 0; i < points.size(); i++) {
                     QGraphicsItem *item = items.at(i);
                     const QPointF &point = points.at(i);
                     const QRectF &rect = item->boundingRect();
-                    m_markerMap[item] = point;
+                    m_markerMap[item] = m_series->pointAt(i);
                     item->setPos(point.x() - rect.width() / 2, point.y() - rect.height() / 2);
-                    if (!m_visible || !clipRect.contains(point))
+                    if (!m_visible || offGridStatus.at(i))
                         item->setVisible(false);
                     else
                         item->setVisible(true);

src/scatterchart/scatterchartitem_p.h +1 -1

                 Q_OBJECT
                 Q_INTERFACES(QGraphicsItem)
             public:
-                explicit ScatterChartItem(QScatterSeries *series, QGraphicsItem* item = 0);
+                explicit ScatterChartItem(QScatterSeries *series, QGraphicsItem *item = 0);
             public:
                 //from QGraphicsItem

src/splinechart/splinechartitem.cpp +196 -16

@@ -22,13 +22,13
22	#include "qsplineseries_p.h"	22	#include "qsplineseries_p.h"
23	#include "chartpresenter_p.h"	23	#include "chartpresenter_p.h"
24	#include "splineanimation_p.h"	24	#include "splineanimation_p.h"
25	#include "a~~bst~~r~~act~~domain_p.h"	25	#include "polardomain_p.h"
26	#include <QPainter>	26	#include <QPainter>
27	#include <QGraphicsSceneMouseEvent>	27	#include <QGraphicsSceneMouseEvent>
28		28
29	QTCOMMERCIALCHART_BEGIN_NAMESPACE	29	QTCOMMERCIALCHART_BEGIN_NAMESPACE
30		30
31	SplineChartItem::SplineChartItem(QSplineSeries series, QGraphicsItem item)	31	SplineChartItem::SplineChartItem(QSplineSeries series, QGraphicsItem item)
32	: XYChart(series,item),	32	: XYChart(series,item),
33	m_series(series),	33	m_series(series),
34	m_pointsVisible(false),	34	m_pointsVisible(false),
@@ -49,8 +49,7 QRectF SplineChartItem::boundingRect() const
49		49
50	QPainterPath SplineChartItem::shape() const	50	QPainterPath SplineChartItem::shape() const
51	{	51	{
52	QPainterPathStroker stroker;	52	return m_fullPath;
53	return stroker.createStroke(m_path);
54	}	53	}
55		54
56	void SplineChartItem::setAnimation(SplineAnimation *animation)	55	void SplineChartItem::setAnimation(SplineAnimation *animation)
@@ -107,20 +106,179 void SplineChartItem::updateGeometry()
107		106
108	Q_ASSERT(points.count() * 2 - 2 == controlPoints.count());	107	Q_ASSERT(points.count() * 2 - 2 == controlPoints.count());
109		108
110	QPainterPath splinePath(~~points~~.at(0));	109	QPainterPath splinePath;
		110	QPainterPath fullPath;
		111	// Use worst case scenario to determine required margin.
		112	qreal margin = m_linePen.width() * 1.42;
		113
		114	if (m_series->chart()->chartType() == QChart::ChartTypePolar) {
		115	QPainterPath splinePathLeft;
		116	QPainterPath splinePathRight;
		117	QPainterPath *currentSegmentPath = 0;
		118	QPainterPath *previousSegmentPath = 0;
		119	qreal minX = domain()->minX();
		120	qreal maxX = domain()->maxX();
		121	qreal minY = domain()->minY();
		122	QPointF currentSeriesPoint = m_series->pointAt(0);
		123	QPointF currentGeometryPoint = points.at(0);
		124	QPointF previousGeometryPoint = points.at(0);
		125	bool pointOffGrid = false;
		126	bool previousPointWasOffGrid = (currentSeriesPoint.x() < minX \|\| currentSeriesPoint.x() > maxX);
		127	m_visiblePoints.clear();
		128	m_visiblePoints.reserve(points.size());
		129
		130	qreal domainRadius = domain()->size().height() / 2.0;
		131	const QPointF centerPoint(domainRadius, domainRadius);
		132
		133	if (!previousPointWasOffGrid) {
		134	fullPath.moveTo(points.at(0));
		135	// Do not draw points for points below minimum Y.
		136	if (m_pointsVisible && currentSeriesPoint.y() >= minY)
		137	m_visiblePoints.append(currentGeometryPoint);
		138	}
		139
		140	qreal leftMarginLine = centerPoint.x() - margin;
		141	qreal rightMarginLine = centerPoint.x() + margin;
		142	qreal horizontal = centerPoint.y();
		143
		144	for (int i = 1; i < points.size(); i++) {
		145	// Interpolating spline fragments accurately is not trivial, and would anyway be ugly
		146	// when thick pen is used, so we work around it by utilizing three separate
		147	// paths for spline segments and clip those with custom regions at paint time.
		148	// "Right" path contains segments that cross the axis line with visible point on the
		149	// right side of the axis line, as well as segments that have one point within the margin
		150	// on the right side of the axis line and another point on the right side of the chart.
		151	// "Left" path contains points with similarly on the left side.
		152	// "Full" path contains rest of the points.
		153	// This doesn't yield perfect results always. E.g. when segment covers more than 90
		154	// degrees and both of the points are within the margin, one in the top half and one in the
		155	// bottom half of the chart, the bottom one gets clipped incorrectly.
		156	// However, this should be rare occurrence in any sensible chart.
		157	currentSeriesPoint = m_series->pointAt(i);
		158	currentGeometryPoint = points.at(i);
		159	pointOffGrid = (currentSeriesPoint.x() < minX \|\| currentSeriesPoint.x() > maxX);
		160
		161	// Draw something unless both off-grid
		162	if (!pointOffGrid \|\| !previousPointWasOffGrid) {
		163	bool dummyOk; // We know points are ok, but this is needed
		164	qreal currentAngle = static_cast<PolarDomain *>(domain())->toAngularCoordinate(currentSeriesPoint.x(), dummyOk);
		165	qreal previousAngle = static_cast<PolarDomain *>(domain())->toAngularCoordinate(m_series->pointAt(i - 1).x(), dummyOk);
		166
		167	if ((qAbs(currentAngle - previousAngle) > 180.0)) {
		168	// If the angle between two points is over 180 degrees (half X range),
		169	// any direct segment between them becomes meaningless.
		170	// In this case two line segments are drawn instead, from previous
		171	// point to the center and from center to current point.
		172	if ((previousAngle < 0.0 \|\| (previousAngle <= 180.0 && previousGeometryPoint.x() < rightMarginLine))
		173	&& previousGeometryPoint.y() < horizontal) {
		174	currentSegmentPath = &splinePathRight;
		175	} else if ((previousAngle > 360.0 \|\| (previousAngle > 180.0 && previousGeometryPoint.x() > leftMarginLine))
		176	&& previousGeometryPoint.y() < horizontal) {
		177	currentSegmentPath = &splinePathLeft;
		178	} else if (previousAngle > 0.0 && previousAngle < 360.0) {
		179	currentSegmentPath = &splinePath;
		180	} else {
		181	currentSegmentPath = 0;
		182	}
		183
		184	if (currentSegmentPath) {
		185	if (previousSegmentPath != currentSegmentPath)
		186	currentSegmentPath->moveTo(previousGeometryPoint);
		187	if (!previousSegmentPath)
		188	fullPath.moveTo(previousGeometryPoint);
		189
		190	currentSegmentPath->lineTo(centerPoint);
		191	fullPath.lineTo(centerPoint);
		192	}
		193
		194	previousSegmentPath = currentSegmentPath;
		195
		196	if ((currentAngle < 0.0 \|\| (currentAngle <= 180.0 && currentGeometryPoint.x() < rightMarginLine))
		197	&& currentGeometryPoint.y() < horizontal) {
		198	currentSegmentPath = &splinePathRight;
		199	} else if ((currentAngle > 360.0 \|\| (currentAngle > 180.0 &&currentGeometryPoint.x() > leftMarginLine))
		200	&& currentGeometryPoint.y() < horizontal) {
		201	currentSegmentPath = &splinePathLeft;
		202	} else if (currentAngle > 0.0 && currentAngle < 360.0) {
		203	currentSegmentPath = &splinePath;
		204	} else {
		205	currentSegmentPath = 0;
		206	}
		207
		208	if (currentSegmentPath) {
		209	if (previousSegmentPath != currentSegmentPath)
		210	currentSegmentPath->moveTo(centerPoint);
		211	if (!previousSegmentPath)
		212	fullPath.moveTo(centerPoint);
		213
		214	currentSegmentPath->lineTo(currentGeometryPoint);
		215	fullPath.lineTo(currentGeometryPoint);
		216	}
		217	} else {
		218	QPointF cp1 = controlPoints[2 * (i - 1)];
		219	QPointF cp2 = controlPoints[(2 * i) - 1];
		220
		221	if (previousAngle < 0.0 \|\| currentAngle < 0.0
		222	\|\| ((previousAngle <= 180.0 && currentAngle <= 180.0)
		223	&& ((previousGeometryPoint.x() < rightMarginLine && previousGeometryPoint.y() < horizontal)
		224	\|\| (currentGeometryPoint.x() < rightMarginLine && currentGeometryPoint.y() < horizontal)))) {
		225	currentSegmentPath = &splinePathRight;
		226	} else if (previousAngle > 360.0 \|\| currentAngle > 360.0
		227	\|\| ((previousAngle > 180.0 && currentAngle > 180.0)
		228	&& ((previousGeometryPoint.x() > leftMarginLine && previousGeometryPoint.y() < horizontal)
		229	\|\| (currentGeometryPoint.x() > leftMarginLine && currentGeometryPoint.y() < horizontal)))) {
		230	currentSegmentPath = &splinePathLeft;
		231	} else {
		232	currentSegmentPath = &splinePath;
		233	}
		234
		235	if (currentSegmentPath != previousSegmentPath)
		236	currentSegmentPath->moveTo(previousGeometryPoint);
		237	if (!previousSegmentPath)
		238	fullPath.moveTo(previousGeometryPoint);
		239
		240	fullPath.cubicTo(cp1, cp2, currentGeometryPoint);
		241	currentSegmentPath->cubicTo(cp1, cp2, currentGeometryPoint);
		242	}
		243	} else {
		244	currentSegmentPath = 0;
		245	}
		246
		247	previousPointWasOffGrid = pointOffGrid;
		248	if (!pointOffGrid && m_pointsVisible && currentSeriesPoint.y() >= minY)
		249	m_visiblePoints.append(currentGeometryPoint);
		250	previousSegmentPath = currentSegmentPath;
		251	previousGeometryPoint = currentGeometryPoint;
		252	}
111		253
112	for (int i = 0; i < points.size() - 1; i++) {	254	m_pathPolarRight = splinePathRight;
113	const QPointF &point = points.at(i + 1);	255	m_pathPolarLeft = splinePathLeft;
114	splinePath.cubicTo(controlPoints[2 * i], controlPoints[2 * i + 1], point);	256	// Note: This construction of m_fullpath is not perfect. The partial segments that are
		257	// outside left/right clip regions at axis boundary still generate hover/click events,
		258	// because shape doesn't get clipped. It doesn't seem possible to do sensibly.
		259	} else { // not polar
		260	splinePath.moveTo(points.at(0));
		261	for (int i = 0; i < points.size() - 1; i++) {
		262	const QPointF &point = points.at(i + 1);
		263	splinePath.cubicTo(controlPoints[2 * i], controlPoints[2 * i + 1], point);
		264	}
		265	fullPath = splinePath;
115	}	266	}
		267	m_path = splinePath;
		268
		269	QPainterPathStroker stroker;
		270	// The full path is comprised of three separate paths.
		271	// This is why we are prepared for the "worst case" scenario, i.e. use always MiterJoin and
		272	// multiply line width with square root of two when defining shape and bounding rectangle.
		273	stroker.setWidth(margin);
		274	stroker.setJoinStyle(Qt::MiterJoin);
		275	stroker.setCapStyle(Qt::SquareCap);
		276	stroker.setMiterLimit(m_linePen.miterLimit());
116		277
117	prepareGeometryChange();	278	prepareGeometryChange();
118	// QPainterPathStroker stroker;
119	// stroker.setWidth(m_linePen.width() / 2.0);
120	// m_path = stroker.createStroke(splinePath);
121	m_path = splinePath;
122	m_rect = splinePath.boundingRect();
123		279
		280	m_fullPath = stroker.createStroke(fullPath);
		281	m_rect = m_fullPath.boundingRect();
124	}	282	}
125		283
126	/*!	284	/*!
@@ -240,16 +398,38 void SplineChartItem::paint(QPainter painter, const QStyleOptionGraphicsItem o
240	Q_UNUSED(widget)	398	Q_UNUSED(widget)
241	Q_UNUSED(option)	399	Q_UNUSED(option)
242		400
		401	QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
		402
243	painter->save();	403	painter->save();
244	painter->setClipRect(QRectF(QPointF(0,0),domain()->size()));
245	painter->setPen(m_linePen);	404	painter->setPen(m_linePen);
246	// painter->setBrush(~~m_linePen.color()~~);	405	painter->setBrush(Qt::NoBrush);
		406
		407	if (m_series->chart()->chartType() == QChart::ChartTypePolar) {
		408	qreal halfWidth = domain()->size().width() / 2.0;
		409	QRectF clipRectLeft = QRectF(0, 0, halfWidth, domain()->size().height());
		410	QRectF clipRectRight = QRectF(halfWidth, 0, halfWidth, domain()->size().height());
		411	QRegion fullPolarClipRegion(clipRect.toRect(), QRegion::Ellipse);
		412	QRegion clipRegionLeft(fullPolarClipRegion.intersected(clipRectLeft.toRect()));
		413	QRegion clipRegionRight(fullPolarClipRegion.intersected(clipRectRight.toRect()));
		414	painter->setClipRegion(clipRegionLeft);
		415	painter->drawPath(m_pathPolarLeft);
		416	painter->setClipRegion(clipRegionRight);
		417	painter->drawPath(m_pathPolarRight);
		418	painter->setClipRegion(fullPolarClipRegion);
		419	} else {
		420	painter->setClipRect(clipRect);
		421	}
247		422
248	painter->drawPath(m_path);	423	painter->drawPath(m_path);
		424
249	if (m_pointsVisible) {	425	if (m_pointsVisible) {
250	painter->setPen(m_pointPen);	426	painter->setPen(m_pointPen);
251	painter->drawPoints(geometryPoints());	427	if (m_series->chart()->chartType() == QChart::ChartTypePolar)
		428	painter->drawPoints(m_visiblePoints);
		429	else
		430	painter->drawPoints(geometryPoints());
252	}	431	}
		432
253	painter->restore();	433	painter->restore();
254	}	434	}
255		435

src/splinechart/splinechartitem_p.h +5 -1

                 Q_OBJECT
                 Q_INTERFACES(QGraphicsItem)
             public:
-                SplineChartItem(QSplineSeries *series, QGraphicsItem* item = 0);
+                SplineChartItem(QSplineSeries *series, QGraphicsItem *item = 0);
                 //from QGraphicsItem
                 QRectF boundingRect() const;
             private:
                 QSplineSeries *m_series;
                 QPainterPath m_path;
+                QPainterPath m_pathPolarRight;
+                QPainterPath m_pathPolarLeft;
+                QPainterPath m_fullPath;
                 QRectF m_rect;
                 QPen m_linePen;
                 QPen m_pointPen;
                 bool m_pointsVisible;
                 QVector<QPointF> m_controlPoints;
+                QVector<QPointF> m_visiblePoints;
                 SplineAnimation *m_animation;
                 friend class SplineAnimation;

src/src.pro +5 -4

                 $$PWD/chartelement.cpp \
                 $$PWD/chartitem.cpp \
                 $$PWD/scroller.cpp \
-                $$PWD/chartlayout.cpp \
+                $$PWD/charttitle.cpp \
-                $$PWD/charttitle.cpp
+                $$PWD/qpolarchart.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartdataset_p.h \
                 $$PWD/chartitem_p.h \
                 $$PWD/qchartview_p.h \
                 $$PWD/scroller_p.h \
                 $$PWD/qabstractseries_p.h \
-                $$PWD/chartlayout_p.h \
                 $$PWD/charttitle_p.h \
                 $$PWD/charthelpers_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qchartglobal.h \
                 $$PWD/qabstractseries.h \
                 $$PWD/qchartview.h \
-                $$PWD/chartsnamespace.h
+                $$PWD/chartsnamespace.h \
+                $$PWD/qpolarchart.h
             include(animations/animations.pri)
             include(areachart/areachart.pri)
             include(splinechart/splinechart.pri)
             include(themes/themes.pri)
             include(xychart/xychart.pri)
+            include(layout/layout.pri)
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS

src/xychart/qxyseries.cpp +21 0

@@ -69,6 +69,18 QTCOMMERCIALCHART_BEGIN_NAMESPACE
69	*/	69	*/
70		70
71	/*!	71	/*!
		72	\qmlproperty AbstractAxis XYSeries::axisAngular
		73	The angular axis used for the series, drawn around the polar chart view.
		74	\sa axisX
		75	*/
		76
		77	/*!
		78	\qmlproperty AbstractAxis XYSeries::axisRadial
		79	The radial axis used for the series, drawn inside the polar chart view.
		80	\sa axisY
		81	*/
		82
		83	/*!
72	\property QXYSeries::pointsVisible	84	\property QXYSeries::pointsVisible
73	Controls if the data points are visible and should be drawn.	85	Controls if the data points are visible and should be drawn.
74	*/	86	*/
@@ -354,6 +366,15 QList<QPointF> QXYSeries::points() const
354	}	366	}
355		367
356	/*!	368	/*!
		369	Returns point at \a index in internal points vector.
		370	*/
		371	const QPointF &QXYSeries::pointAt(int index) const
		372	{
		373	Q_D(const QXYSeries);
		374	return d->m_points.at(index);
		375	}
		376
		377	/*!
357	Returns number of data points within series.	378	Returns number of data points within series.
358	*/	379	*/
359	int QXYSeries::count() const	380	int QXYSeries::count() const

src/xychart/qxyseries.h +1 0

                 int count() const;
                 QList<QPointF> points() const;
+                const QPointF &pointAt(int index) const;
                 QXYSeries &operator << (const QPointF &point);
                 QXYSeries &operator << (const QList<QPointF> &points);

src/xychart/xychart.cpp +29 -2

             #include "chartpresenter_p.h"
             #include "abstractdomain_p.h"
             #include "qxymodelmapper.h"
+            #include "qabstractaxis_p.h"
             #include <QPainter>
             #include <QAbstractItemModel>
             //TODO: optimize : remove points which are not visible
-            XYChart::XYChart(QXYSeries *series,QGraphicsItem* item):
+            XYChart::XYChart(QXYSeries *series, QGraphicsItem *item):
                   ChartItem(series->d_func(),item),
                   m_series(series),
                   m_animation(0),
                 QObject::connect(this, SIGNAL(hovered(QPointF,bool)), series, SIGNAL(hovered(QPointF,bool)));
             }
-            void XYChart::setGeometryPoints(const QVector<QPointF>& points)
+            void XYChart::setGeometryPoints(const QVector<QPointF> &points)
             {
                 m_points = points;
             }
                 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());
+                for (int i = 0; i < m_points.size(); i++) {
+                    const QPointF &seriesPoint = m_series->pointAt(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)
             {

src/xychart/xychart_p.h +5 -2

             {
                 Q_OBJECT
             public:
-                explicit XYChart(QXYSeries *series,QGraphicsItem* item = 0);
+                explicit XYChart(QXYSeries *series,QGraphicsItem *item = 0);
                 ~XYChart() {}
-                void setGeometryPoints(const QVector<QPointF>& points);
+                void setGeometryPoints(const QVector<QPointF> &points);
                 QVector<QPointF> geometryPoints() const { return m_points; }
                 void setAnimation(XYAnimation *animation);
                 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);

tests/auto/inc/tst_definitions.h +44 0

@@ -21,6 +21,7
21	#ifndef TST_DEFINITIONS_H	21	#ifndef TST_DEFINITIONS_H
22	#define TST_DEFINITIONS_H	22	#define TST_DEFINITIONS_H
23		23
		24	#include "qpolarchart.h"
24	#include <QtTest/QtTest>	25	#include <QtTest/QtTest>
25	#include <QPushButton>	26	#include <QPushButton>
26		27
@@ -63,6 +64,16 namespace QTest
63	QSKIP("Cannot test mouse events in this environment"); \	64	QSKIP("Cannot test mouse events in this environment"); \
64	} while (0); \	65	} while (0); \
65	}	66	}
		67
		68	#define SKIP_ON_POLAR() { \
		69	if (isPolarTest()) \
		70	QSKIP("Test not supported by polar chart"); \
		71	}
		72
		73	#define SKIP_ON_CARTESIAN() { \
		74	if (!isPolarTest()) \
		75	QSKIP("Test not supported by cartesian chart"); \
		76	}
66	#else	77	#else
67	#define SKIP_IF_CANNOT_TEST_MOUSE_EVENTS() { \	78	#define SKIP_IF_CANNOT_TEST_MOUSE_EVENTS() { \
68	do { \	79	do { \
@@ -76,6 +87,39 namespace QTest
76	QSKIP("Cannot test mouse events in this environment", SkipAll); \	87	QSKIP("Cannot test mouse events in this environment", SkipAll); \
77	} while (0); \	88	} while (0); \
78	}	89	}
		90
		91	#define SKIP_ON_POLAR() { \
		92	if (isPolarTest()) \
		93	QSKIP("Test not supported by polar chart", SkipAll); \
		94	}
		95
		96	#define SKIP_ON_CARTESIAN() { \
		97	if (!isPolarTest()) \
		98	QSKIP("Test not supported by cartesian chart", SkipAll); \
		99	}
79	#endif	100	#endif
80		101
		102	static inline bool isPolarTest()
		103	{
		104	static bool isPolar = false;
		105	static bool polarEnvChecked = false;
		106	if (!polarEnvChecked) {
		107	isPolar = !(qgetenv("TEST_POLAR_CHART").isEmpty());
		108	polarEnvChecked = true;
		109	if (isPolar)
		110	qDebug() << "TEST_POLAR_CHART found -> Testing polar chart!";
		111	}
		112	return isPolar;
		113	}
		114
		115	static inline QtCommercialChart::QChart *newQChartOrQPolarChart()
		116	{
		117	if (isPolarTest())
		118	return new QtCommercialChart::QPolarChart();
		119	else
		120	return new QtCommercialChart::QChart();
		121	}
		122
		123
		124
81	#endif // TST_DEFINITIONS_H	125	#endif // TST_DEFINITIONS_H

tests/auto/qabstractaxis/tst_qabstractaxis.cpp +1 -1

             {
                 m_axis = axis;
                 m_series = series;
-                m_view = new QChartView(new QChart());
+                m_view = new QChartView(newQChartOrQPolarChart());
                 m_chart = m_view->chart();
             }

tests/auto/qchart/tst_qchart.cpp +56 -25

                 void zoomOut();
                 void createDefaultAxesForLineSeries_data();
                 void createDefaultAxesForLineSeries();
+                void axisPolarOrientation();
             private:
                 void createTestData();
             void tst_QChart::init()
             {
-                m_view = new QChartView(new QChart());
+                m_view = new QChartView(newQChartOrQPolarChart());
                 m_chart = m_view->chart();
             }
                 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
                 QAbstractSeries* scatter = new QScatterSeries(this);
                 QAbstractSeries* spline = new QSplineSeries(this);
-                QAbstractSeries* pie = new QPieSeries(this);
-                QAbstractSeries* bar = new QBarSeries(this);
-                QAbstractSeries* percent = new QPercentBarSeries(this);
-                QAbstractSeries* stacked = new QStackedBarSeries(this);
                 QTest::newRow("lineSeries") << line;
                 QTest::newRow("areaSeries") << area;
                 QTest::newRow("scatterSeries") << scatter;
                 QTest::newRow("splineSeries") << spline;
-                QTest::newRow("pieSeries") << pie;
-                QTest::newRow("barSeries") << bar;
-                QTest::newRow("percentBarSeries") << percent;
-                QTest::newRow("stackedBarSeries") << stacked;
+                if (!isPolarTest()) {
+                    QAbstractSeries* pie = new QPieSeries(this);
+                    QAbstractSeries* bar = new QBarSeries(this);
+                    QAbstractSeries* percent = new QPercentBarSeries(this);
+                    QAbstractSeries* stacked = new QStackedBarSeries(this);
+                    QTest::newRow("pieSeries") << pie;
+                    QTest::newRow("barSeries") << bar;
+                    QTest::newRow("percentBarSeries") << percent;
+                    QTest::newRow("stackedBarSeries") << stacked;
+                }
             }
             void tst_QChart::addSeries()
                 QTest::newRow("categories,areaSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
                 QTest::newRow("categories,scatterSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QScatterSeries(this);
                 QTest::newRow("categories,splineSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QSplineSeries(this);
-                QTest::newRow("categories,pieSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPieSeries(this);
+                if (!isPolarTest()) {
-                QTest::newRow("categories,barSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QBarSeries(this);
+                    QTest::newRow("categories,pieSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPieSeries(this);
-                QTest::newRow("categories,percentBarSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
+                    QTest::newRow("categories,barSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QBarSeries(this);
-                QTest::newRow("categories,stackedBarSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
+                    QTest::newRow("categories,percentBarSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
+                    QTest::newRow("categories,stackedBarSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
+                }
                 QTest::newRow("value,lineSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QLineSeries(this);
                 QTest::newRow("value,areaSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
                 QTest::newRow("value,scatterSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QScatterSeries(this);
                 QTest::newRow("value,splineSeries") << (QAbstractAxis*) new QValueAxis() <<  (QAbstractSeries*) new QSplineSeries(this);
-                QTest::newRow("value,pieSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPieSeries(this);
+                if (!isPolarTest()) {
-                QTest::newRow("value,barSeries") << (QAbstractAxis*) new QValueAxis() <<   (QAbstractSeries*) new QBarSeries(this);
+                    QTest::newRow("value,pieSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPieSeries(this);
-                QTest::newRow("value,percentBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
+                    QTest::newRow("value,barSeries") << (QAbstractAxis*) new QValueAxis() <<   (QAbstractSeries*) new QBarSeries(this);
-                QTest::newRow("value,stackedBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
+                    QTest::newRow("value,percentBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
+                    QTest::newRow("value,stackedBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
+                }
             }
             void tst_QChart::axisX()
                 series2->append(series2minX, series2minY);
                 series2->append(series2midX, series2midY);
                 series2->append(series2maxX, series2maxY);
-                QChart chart;
+                QChart *chart = newQChartOrQPolarChart();
-                chart.addSeries(series1);
+                chart->addSeries(series1);
-                chart.addSeries(series2);
+                chart->addSeries(series2);
-                chart.createDefaultAxes();
+                chart->createDefaultAxes();
-                QValueAxis *xAxis = (QValueAxis *)chart.axisX();
+                QValueAxis *xAxis = (QValueAxis *)chart->axisX();
                 QCOMPARE(xAxis->min(), overallminX);
                 QCOMPARE(xAxis->max(), overallmaxX);
-                QValueAxis *yAxis = (QValueAxis *)chart.axisY();
+                QValueAxis *yAxis = (QValueAxis *)chart->axisY();
                 QCOMPARE(yAxis->min(), overallminY);
                 QCOMPARE(yAxis->max(), overallmaxY);
                 QLineSeries *series3 = new QLineSeries(this);
                 series3->append(0, 0);
                 series3->append(100, 100);
                 // Adding a new series should not change the axes as they have not been told to update
-                chart.addSeries(series3);
+                chart->addSeries(series3);
                 QCOMPARE(xAxis->min(), overallminX);
                 QCOMPARE(xAxis->max(), overallmaxX);
                 QCOMPARE(yAxis->min(), overallminY);
                 QCOMPARE(yAxis->max(), overallmaxY);
+            }
+            void tst_QChart::axisPolarOrientation()
+            {
+                QLineSeries* series1 = new QLineSeries(this);
+                series1->append(1, 2);
+                series1->append(2, 4);
+                series1->append(3, 8);
+                QPolarChart chart;
+                chart.addSeries(series1);
+                QValueAxis *xAxis = new QValueAxis();
+                QValueAxis *yAxis = new QValueAxis();
+                chart.addAxis(xAxis, QPolarChart::PolarOrientationAngular);
+                chart.addAxis(yAxis, QPolarChart::PolarOrientationRadial);
+                QList<QAbstractAxis *> xAxes = chart.axes(QPolarChart::PolarOrientationAngular);
+                QList<QAbstractAxis *> yAxes = chart.axes(QPolarChart::PolarOrientationRadial);
+                QCOMPARE(xAxes.size(), 1);
+                QCOMPARE(yAxes.size(), 1);
+                QCOMPARE(xAxes[0], xAxis);
+                QCOMPARE(yAxes[0], yAxis);
+                QCOMPARE(chart.axisPolarOrientation(xAxes[0]), QPolarChart::PolarOrientationAngular);
+                QCOMPARE(chart.axisPolarOrientation(yAxes[0]), QPolarChart::PolarOrientationRadial);
             }
             QTEST_MAIN(tst_QChart)

tests/auto/qchartview/tst_qchartview.cpp +12 -5

             void tst_QChartView::init()
             {
-                m_view = new QChartView(new QChart());
+                m_view = new QChartView(newQChartOrQPolarChart());
                 m_view->chart()->legend()->setVisible(false);
             }
                 QTest::addColumn<QPoint>("min");
                 QTest::addColumn<QPoint>("max");
-                QTest::newRow("HorizonalRubberBand") << QChartView::RubberBands(QChartView::HorizonalRubberBand) << 0 << 1 << QPoint(5,5) << QPoint(5,5);
+                if (isPolarTest()) {
-                QTest::newRow("VerticalRubberBand") <<  QChartView::RubberBands(QChartView::VerticalRubberBand) << 1 << 0 << QPoint(5,5) << QPoint(5,5);
+                    QTest::newRow("HorizonalRubberBand") << QChartView::RubberBands(QChartView::HorizonalRubberBand) << 0 << 0 << QPoint(5,5) << QPoint(5,5);
-                QTest::newRow("RectangleRubberBand") <<  QChartView::RubberBands(QChartView::RectangleRubberBand) << 1 << 1 << QPoint(5,5) << QPoint(5,5);
+                    QTest::newRow("VerticalRubberBand") <<  QChartView::RubberBands(QChartView::VerticalRubberBand) << 0 << 0 << QPoint(5,5) << QPoint(5,5);
+                    QTest::newRow("RectangleRubberBand") <<  QChartView::RubberBands(QChartView::RectangleRubberBand) << 0 << 0 << QPoint(5,5) << QPoint(5,5);
+                } else {
+                    QTest::newRow("HorizonalRubberBand") << QChartView::RubberBands(QChartView::HorizonalRubberBand) << 0 << 1 << QPoint(5,5) << QPoint(5,5);
+                    QTest::newRow("VerticalRubberBand") <<  QChartView::RubberBands(QChartView::VerticalRubberBand) << 1 << 0 << QPoint(5,5) << QPoint(5,5);
+                    QTest::newRow("RectangleRubberBand") <<  QChartView::RubberBands(QChartView::RectangleRubberBand) << 1 << 1 << QPoint(5,5) << QPoint(5,5);
+                }
             }
             void tst_QChartView::rubberBand()
                 series1->append(1,1);
                 oldChart->addSeries(series1);
-                QPointer<QChart> newChart = new QChart();
+                QPointer<QChart> newChart = newQChartOrQPolarChart();
                 QLineSeries *series2 = new QLineSeries();
                 series2->append(0,1);
                 series2->append(1,0);

tests/auto/qlegend/tst_qlegend.cpp +16 -3

             private:
                 QChart *m_chart;
             };
             void tst_QLegend::initTestCase()
             void tst_QLegend::init()
             {
-                m_chart = new QChart();
+                m_chart = newQChartOrQPolarChart();
             }
             void tst_QLegend::cleanup()
             void tst_QLegend::qpieLegendMarker()
             {
+                SKIP_ON_POLAR();
                 QVERIFY(m_chart);
                 QLegend *legend = m_chart->legend();
             void tst_QLegend::qbarLegendMarker()
             {
+                SKIP_ON_POLAR();
                 QVERIFY(m_chart);
                 QLegend *legend = m_chart->legend();
             void tst_QLegend::markers()
             {
+                SKIP_ON_POLAR();
                 QVERIFY(m_chart);
                 QLegend *legend = m_chart->legend();
             void tst_QLegend::addAndRemoveSeries()
             {
+                SKIP_ON_POLAR();
                 QVERIFY(m_chart);
                 QLegend *legend = m_chart->legend();
             void tst_QLegend::pieMarkerProperties()
             {
+                SKIP_ON_POLAR();
                 QVERIFY(m_chart);
                 QLegend *legend = m_chart->legend();
             void tst_QLegend::barMarkerProperties()
             {
+                SKIP_ON_POLAR();
                 QVERIFY(m_chart);
                 QLegend *legend = m_chart->legend();
             void tst_QLegend::markerSignals()
             {
+                SKIP_ON_POLAR();
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
-                QChart *chart = new QChart();
+                QChart *chart = newQChartOrQPolarChart();
                 QLegend *legend = chart->legend();
                 QBarSeries *bar = new QBarSeries();

tests/auto/qml/tst_qml.cpp +38 -28

@@ -36,7 +36,8 private slots:
36	void checkPlugin();	36	void checkPlugin();
37	private:	37	private:
38	QString componentErrors(const QDeclarativeComponent* component) const;	38	QString componentErrors(const QDeclarativeComponent* component) const;
39	QString imports();	39	QString imports_1_1();
		40	QString imports_1_3();
40		41
41	};	42	};
42		43
@@ -53,12 +54,18 QString tst_QML::componentErrors(const QDeclarativeComponent* component) const
53	return errors.join("\n");	54	return errors.join("\n");
54	}	55	}
55		56
56	QString tst_QML::imports()	57	QString tst_QML::imports_1_1()
57	{	58	{
58	return "import QtQuick 1.0 \n"	59	return "import QtQuick 1.0 \n"
59	"import QtCommercial.Chart 1.1 \n";	60	"import QtCommercial.Chart 1.1 \n";
60	}	61	}
61		62
		63	QString tst_QML::imports_1_3()
		64	{
		65	return "import QtQuick 1.0 \n"
		66	"import QtCommercial.Chart 1.3 \n";
		67	}
		68
62		69
63	void tst_QML::initTestCase()	70	void tst_QML::initTestCase()
64	{	71	{
@@ -82,34 +89,37 void tst_QML::checkPlugin_data()
82	{	89	{
83	QTest::addColumn<QString>("source");	90	QTest::addColumn<QString>("source");
84		91
85	QTest::newRow("createChartView") << imports() + "ChartView{}";	92	QTest::newRow("createChartView") << imports_1_1() + "ChartView{}";
86	QTest::newRow("XYPoint") << imports() + "XYPoint{}";	93	QTest::newRow("XYPoint") << imports_1_1() + "XYPoint{}";
87	QTest::newRow("scatterSeries") << imports() + "ScatterSeries{}";	94	QTest::newRow("scatterSeries") << imports_1_1() + "ScatterSeries{}";
88	QTest::newRow("lineSeries") << imports() + "LineSeries{}";	95	QTest::newRow("lineSeries") << imports_1_1() + "LineSeries{}";
89	QTest::newRow("splineSeries") << imports() + "SplineSeries{}";	96	QTest::newRow("splineSeries") << imports_1_1() + "SplineSeries{}";
90	QTest::newRow("areaSeries") << imports() + "AreaSeries{}";	97	QTest::newRow("areaSeries") << imports_1_1() + "AreaSeries{}";
91	QTest::newRow("barSeries") << imports() + "BarSeries{}";	98	QTest::newRow("barSeries") << imports_1_1() + "BarSeries{}";
92	QTest::newRow("stackedBarSeries") << imports() + "StackedBarSeries{}";	99	QTest::newRow("stackedBarSeries") << imports_1_1() + "StackedBarSeries{}";
93	QTest::newRow("precentBarSeries") << imports() + "PercentBarSeries{}";	100	QTest::newRow("precentBarSeries") << imports_1_1() + "PercentBarSeries{}";
94	QTest::newRow("horizonatlBarSeries") << imports() + "HorizontalBarSeries{}";	101	QTest::newRow("horizonatlBarSeries") << imports_1_1() + "HorizontalBarSeries{}";
95	QTest::newRow("horizonatlStackedBarSeries") << imports() + "HorizontalStackedBarSeries{}";	102	QTest::newRow("horizonatlStackedBarSeries") << imports_1_1() + "HorizontalStackedBarSeries{}";
96	QTest::newRow("horizonatlstackedBarSeries") << imports() + "HorizontalPercentBarSeries{}";	103	QTest::newRow("horizonatlstackedBarSeries") << imports_1_1() + "HorizontalPercentBarSeries{}";
97	QTest::newRow("pieSeries") << imports() + "PieSeries{}";	104	QTest::newRow("pieSeries") << imports_1_1() + "PieSeries{}";
98	QTest::newRow("PieSlice") << imports() + "PieSlice{}";	105	QTest::newRow("PieSlice") << imports_1_1() + "PieSlice{}";
99	QTest::newRow("BarSet") << imports() + "BarSet{}";	106	QTest::newRow("BarSet") << imports_1_1() + "BarSet{}";
100	QTest::newRow("HXYModelMapper") << imports() + "HXYModelMapper{}";	107	QTest::newRow("HXYModelMapper") << imports_1_1() + "HXYModelMapper{}";
101	QTest::newRow("VXYModelMapper") << imports() + "VXYModelMapper{}";	108	QTest::newRow("VXYModelMapper") << imports_1_1() + "VXYModelMapper{}";
102	QTest::newRow("HPieModelMapper") << imports() + "HPieModelMapper{}";	109	QTest::newRow("HPieModelMapper") << imports_1_1() + "HPieModelMapper{}";
103	QTest::newRow("HPieModelMapper") << imports() + "HPieModelMapper{}";	110	QTest::newRow("HPieModelMapper") << imports_1_1() + "HPieModelMapper{}";
104	QTest::newRow("HBarModelMapper") << imports() + "HBarModelMapper{}";	111	QTest::newRow("HBarModelMapper") << imports_1_1() + "HBarModelMapper{}";
105	QTest::newRow("VBarModelMapper") << imports() + "VBarModelMapper{}";	112	QTest::newRow("VBarModelMapper") << imports_1_1() + "VBarModelMapper{}";
106	QTest::newRow("ValueAxis") << imports() + "ValueAxis{}";	113	QTest::newRow("ValueAxis") << imports_1_1() + "ValueAxis{}";
107	#ifndef QT_ON_ARM	114	#ifndef QT_ON_ARM
108	QTest::newRow("DateTimeAxis") << imports() + "DateTimeAxis{}";	115	QTest::newRow("DateTimeAxis") << imports_1_1() + "DateTimeAxis{}";
109	#endif	116	#endif
110	QTest::newRow("CategoryAxis") << imports() + "CategoryAxis{}";	117	QTest::newRow("CategoryAxis") << imports_1_1() + "CategoryAxis{}";
111	QTest::newRow("CategoryRange") << imports() + "CategoryRange{}";	118	QTest::newRow("CategoryRange") << imports_1_1() + "CategoryRange{}";
112	QTest::newRow("BarCategoryAxis") << imports() + "BarCategoryAxis{}";	119	QTest::newRow("BarCategoryAxis") << imports_1_1() + "BarCategoryAxis{}";
		120
		121	QTest::newRow("createPolarChartView") << imports_1_3() + "PolarChartView{}";
		122	//QTest::newRow("LogValueAxis") << imports_1_3() + "LogValueAxis{}";
113	}	123	}
114		124
115	void tst_QML::checkPlugin()	125	void tst_QML::checkPlugin()

tests/auto/qxymodelmapper/tst_qxymodelmapper.cpp +2 -1

             #include <qvxymodelmapper.h>
             #include <qhxymodelmapper.h>
             #include <QStandardItemModel>
+            #include "tst_definitions.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             void tst_qxymodelmapper::initTestCase()
             {
-                m_chart = new QChart;
+                m_chart = newQChartOrQPolarChart();
                 QChartView *chartView = new QChartView(m_chart);
                 chartView->show();
             }

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

             void tst_QXYSeries::init()
             {
-                m_view = new QChartView(new QChart());
+                m_view = new QChartView(newQChartOrQPolarChart());
                 m_chart = m_view->chart();
             }

tests/tests.pro +2 -1

                 auto \
                 qmlchartproperties \
                 qmlchartaxis \
-                presenterchart
+                presenterchart \
+                polarcharttest
             contains(QT_CONFIG, opengl) {
                 SUBDIRS +=  chartwidgettest \

src/axis/chartaxis.cpp removed 0 -547

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (547 lines changed) Show them Hide them

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