HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2273:1c49aa901cb2

Refactors internals...

Michal Klocek -

r2273:1c49aa901cb2

parent child

Context file:

r2273:1c49aa901cb2

Expand all files

src/chartitem.cpp created 644 +46 0

@@ -0,0 +1,46
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "chartitem_p.h"
	22	#include "qabstractseries_p.h"
	23	#include "domain_p.h"
	24
	25	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	26
	27	ChartItem::ChartItem(QAbstractSeriesPrivate series,QGraphicsItem item):
	28	ChartElement(item),
	29	m_series(series)
	30	{
	31
	32	}
	33
	34	QSharedPointer<Domain> ChartItem::domain() const
	35	{
	36	return m_series->domain();
	37	}
	38
	39	void ChartItem::handleDomainUpdated()
	40	{
	41	qWarning() << __FUNCTION__<< "Slot not implemented";
	42	}
	43
	44	#include "moc_chartitem_p.cpp"
	45
	46	QTCOMMERCIALCHART_END_NAMESPACE

src/chartthememanager.cpp created 644 +259 0

@@ -0,0 +1,259
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20	#include "qabstractseries_p.h"
	21	#include "qabstractaxis_p.h"
	22	#include <QTime>
	23	//themes
	24	#include "chartthemesystem_p.h"
	25	#include "chartthemelight_p.h"
	26	#include "chartthemebluecerulean_p.h"
	27	#include "chartthemedark_p.h"
	28	#include "chartthemebrownsand_p.h"
	29	#include "chartthemebluencs_p.h"
	30	#include "chartthemehighcontrast_p.h"
	31	#include "chartthemeblueicy_p.h"
	32
	33	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	34
	35	ChartThemeManager::ChartThemeManager(QChart* chart) :
	36	m_chart(chart)
	37	{
	38	qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
	39	}
	40
	41
	42	void ChartThemeManager::setTheme(QChart::ChartTheme theme)
	43	{
	44	if(m_theme.isNull() \|\| theme != m_theme->id())
	45	{
	46	switch (theme) {
	47	case QChart::ChartThemeLight:
	48	m_theme.reset(new ChartThemeLight());
	49	break;
	50	case QChart::ChartThemeBlueCerulean:
	51	m_theme.reset(new ChartThemeBlueCerulean());
	52	break;
	53	case QChart::ChartThemeDark:
	54	m_theme.reset(new ChartThemeDark());
	55	break;
	56	case QChart::ChartThemeBrownSand:
	57	m_theme.reset(new ChartThemeBrownSand());
	58	break;
	59	case QChart::ChartThemeBlueNcs:
	60	m_theme.reset(new ChartThemeBlueNcs());
	61	break;
	62	case QChart::ChartThemeHighContrast:
	63	m_theme.reset(new ChartThemeHighContrast());
	64	break;
	65	case QChart::ChartThemeBlueIcy:
	66	m_theme.reset(new ChartThemeBlueIcy());
	67	break;
	68	default:
	69	m_theme.reset(new ChartThemeSystem());
	70	break;
	71	}
	72
	73	if(!m_theme.isNull())
	74	{
	75	decorateChart(m_chart,m_theme.data(),true);
	76	decorateLegend(m_chart->legend(),m_theme.data(),true);
	77	foreach(QAbstractAxis* axis, m_axisList) {
	78	axis->d_ptr->initializeTheme(m_theme.data(),true);
	79	}
	80	foreach(QAbstractSeries* series, m_seriesMap.keys()) {
	81	series->d_ptr->initializeTheme(m_seriesMap[series],m_theme.data(),true);
	82	}
	83
	84	}
	85	}
	86	}
	87
	88	void ChartThemeManager::decorateChart(QChart chart,ChartTheme theme,bool force) const
	89	{
	90	QBrush brush;
	91
	92	if (force \|\| brush == chart->backgroundBrush())
	93	chart->setBackgroundBrush(theme->chartBackgroundGradient());
	94
	95	chart->setTitleFont(theme->masterFont());
	96	chart->setTitleBrush(theme->labelBrush());
	97	chart->setDropShadowEnabled(theme->isBackgroundDropShadowEnabled());
	98	}
	99
	100	void ChartThemeManager::decorateLegend(QLegend legend, ChartTheme theme, bool force) const
	101	{
	102	QPen pen;
	103	QBrush brush;
	104	QFont font;
	105
	106	if (force \|\| pen == legend->pen())
	107	legend->setPen(theme->axisLinePen());
	108
	109	if (force \|\| brush == legend->brush())
	110	legend->setBrush(theme->chartBackgroundGradient());
	111
	112	if (force \|\| font == legend->font())
	113	legend->setFont(theme->labelFont());
	114
	115	if (force \|\| brush == legend->labelBrush())
	116	legend->setLabelBrush(theme->labelBrush());
	117	}
	118
	119	int ChartThemeManager::createIndexKey(QList<int> keys) const
	120	{
	121	qSort(keys);
	122
	123	int key = 0;
	124	QList<int>::iterator i;
	125	i = keys.begin();
	126
	127	while (i != keys.end()) {
	128	if (*i != key)
	129	break;
	130	key++;
	131	i++;
	132	}
	133
	134	return key;
	135	}
	136
	137	int ChartThemeManager::seriesCount(QAbstractSeries::SeriesType type) const
	138	{
	139	int count = 0;
	140	QList<QAbstractSeries *> series = m_seriesMap.keys();
	141	foreach(QAbstractSeries *s, series) {
	142	if (s->type() == type)
	143	count++;
	144	}
	145	return count;
	146	}
	147
	148	void ChartThemeManager::handleSeriesAdded(QAbstractSeries *series)
	149	{
	150	int key = createIndexKey(m_seriesMap.values());
	151	m_seriesMap.insert(series,key);
	152	series->d_ptr->initializeTheme(key,m_theme.data(),false);
	153	}
	154
	155	void ChartThemeManager::handleSeriesRemoved(QAbstractSeries *series)
	156	{
	157	m_seriesMap.remove(series);
	158	}
	159
	160	void ChartThemeManager::handleAxisAdded(QAbstractAxis *axis)
	161	{
	162	m_axisList.append(axis);
	163	axis->d_ptr->initializeTheme(m_theme.data(),false);
	164	}
	165
	166	void ChartThemeManager::handleAxisRemoved(QAbstractAxis *axis)
	167	{
	168	m_axisList.removeAll(axis);
	169	}
	170
	171	void ChartThemeManager::updateSeries(QAbstractSeries *series)
	172	{
	173	if(m_seriesMap.contains(series)){
	174	series->d_ptr->initializeTheme(m_seriesMap[series],m_theme.data(),false);
	175	}
	176	}
	177	QList<QGradient> ChartThemeManager::generateSeriesGradients(const QList<QColor>& colors)
	178	{
	179	QList<QGradient> result;
	180	// Generate gradients in HSV color space
	181	foreach (const QColor &color, colors) {
	182	QLinearGradient g;
	183	qreal h = color.hsvHueF();
	184	qreal s = color.hsvSaturationF();
	185
	186	// TODO: tune the algorithm to give nice results with most base colors defined in
	187	// most themes. The rest of the gradients we can define manually in theme specific
	188	// implementation.
	189	QColor start = color;
	190	start.setHsvF(h, 0.0, 1.0);
	191	g.setColorAt(0.0, start);
	192
	193	g.setColorAt(0.5, color);
	194
	195	QColor end = color;
	196	end.setHsvF(h, s, 0.25);
	197	g.setColorAt(1.0, end);
	198
	199	result << g;
	200	}
	201
	202	return result;
	203	}
	204
	205
	206	QColor ChartThemeManager::colorAt(const QColor &start, const QColor &end, qreal pos)
	207	{
	208	Q_ASSERT(pos >= 0.0 && pos <= 1.0);
	209	qreal r = start.redF() + ((end.redF() - start.redF()) * pos);
	210	qreal g = start.greenF() + ((end.greenF() - start.greenF()) * pos);
	211	qreal b = start.blueF() + ((end.blueF() - start.blueF()) * pos);
	212	QColor c;
	213	c.setRgbF(r, g, b);
	214	return c;
	215	}
	216
	217	QColor ChartThemeManager::colorAt(const QGradient &gradient, qreal pos)
	218	{
	219	Q_ASSERT(pos >= 0 && pos <= 1.0);
	220
	221	QGradientStops stops = gradient.stops();
	222	int count = stops.count();
	223
	224	// find previous stop relative to position
	225	QGradientStop prev = stops.first();
	226	for (int i = 0; i < count; i++) {
	227	QGradientStop stop = stops.at(i);
	228	if (pos > stop.first)
	229	prev = stop;
	230
	231	// given position is actually a stop position?
	232	if (pos == stop.first) {
	233	//qDebug() << "stop color" << pos;
	234	return stop.second;
	235	}
	236	}
	237
	238	// find next stop relative to position
	239	QGradientStop next = stops.last();
	240	for (int i = count - 1; i >= 0; i--) {
	241	QGradientStop stop = stops.at(i);
	242	if (pos < stop.first)
	243	next = stop;
	244	}
	245
	246	//qDebug() << "prev" << prev.first << "pos" << pos << "next" << next.first;
	247
	248	qreal range = next.first - prev.first;
	249	qreal posDelta = pos - prev.first;
	250	qreal relativePos = posDelta / range;
	251
	252	//qDebug() << "range" << range << "posDelta" << posDelta << "relativePos" << relativePos;
	253
	254	return colorAt(prev.second, next.second, relativePos);
	255	}
	256
	257	#include "moc_chartthememanager_p.cpp"
	258
	259	QTCOMMERCIALCHART_END_NAMESPACE

src/chartthememanager_p.h created 644 +84 0

@@ -0,0 +1,84
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// 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 CHARTTHEMEMANAGER_H
	31	#define CHARTTHEMEMANAGER_H
	32
	33	#include "qchartglobal.h"
	34	#include "qchart.h"
	35	#include <QColor>
	36	#include <QGradientStops>
	37
	38	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	39	class ChartTheme;
	40
	41	class ChartThemeManager: public QObject
	42	{
	43	Q_OBJECT
	44	public:
	45	enum BackgroundShadesMode {
	46	BackgroundShadesNone = 0,
	47	BackgroundShadesVertical,
	48	BackgroundShadesHorizontal,
	49	BackgroundShadesBoth
	50	};
	51
	52	public:
	53	explicit ChartThemeManager(QChart* chart);
	54	void setTheme(QChart::ChartTheme theme);
	55	ChartTheme* theme() const { return m_theme.data(); }
	56	void decorateChart(QChart chart, ChartTheme theme, bool force = false) const;
	57	void decorateLegend(QLegend legend, ChartTheme theme, bool force = false) const;
	58	void updateSeries(QAbstractSeries *series);
	59
	60	public:
	61	static QList<QGradient> generateSeriesGradients(const QList<QColor>& colors);
	62	static QColor colorAt(const QColor &start, const QColor &end, qreal pos);
	63	static QColor colorAt(const QGradient &gradient, qreal pos);
	64
	65	private:
	66	int createIndexKey(QList<int> keys) const;
	67	int seriesCount(QAbstractSeries::SeriesType type) const;
	68
	69	public Q_SLOTS:
	70	void handleSeriesAdded(QAbstractSeries *series);
	71	void handleSeriesRemoved(QAbstractSeries *series);
	72	void handleAxisAdded(QAbstractAxis *axis);
	73	void handleAxisRemoved(QAbstractAxis *axis);
	74
	75	protected:
	76	QScopedPointer<ChartTheme> m_theme;
	77	QMap<QAbstractSeries *,int> m_seriesMap;
	78	QList<QAbstractAxis *> m_axisList;
	79	QChart* m_chart;
	80	};
	81
	82	QTCOMMERCIALCHART_END_NAMESPACE
	83
	84	#endif // CHARTTHEME_H

demos/audio/widget.cpp +3 -3

                 QValueAxis *axisX = new QValueAxis;
                 axisX->setRange(0, 2000);
                 axisX->setLabelFormat("%g");
-                axisX->setTitle("Samples");
+                axisX->setTitleText("Samples");
                 QValueAxis *axisY = new QValueAxis;
                 axisY->setRange(-1, 1);
-                axisY->setTitle("Audio level");
+                axisY->setTitleText("Audio level");
                 m_chart->setAxisX(axisX, m_series);
                 m_chart->setAxisY(axisY, m_series);
                 m_chart->legend()->hide();
                 m_chart->setTitle("Data from the microphone");

demos/chartthemes/themewidget.cpp 0 -2

             QChart *ThemeWidget::createAreaChart() const
             {
                 QChart *chart = new QChart();
-            //    chart->axisX()->setNiceNumbersEnabled(true);
-            //    chart->axisY()->setNiceNumbersEnabled(true);
                 chart->setTitle("Area chart");
                 // The lower series initialized to zero values

demos/chartviewer/charts/axis/barcategoryaxisx.cpp +2 -2

                 QChart *createChart(const DataTable &table)
                 {
                     QChart *chart = BarCategoryAxisX::createChart(table);
-                    chart->axisX()->setTitle("Axis X");
+                    chart->axisX()->setTitleText("Axis X");
-                    chart->axisY()->setTitle("Axis Y");
+                    chart->axisY()->setTitleText("Axis Y");
                     chart->setTitle(" BarCateogry X , Value Y, title");
                     return chart;
                 }

demos/chartviewer/charts/axis/barcategoryaxisy.cpp +2 -2

                 QChart *createChart(const DataTable &table)
                 {
                     QChart *chart = BarCategoryAxisY::createChart(table);
-                    chart->axisX()->setTitle("Axis X");
+                    chart->axisX()->setTitleText("Axis X");
-                    chart->axisY()->setTitle("Axis Y");
+                    chart->axisY()->setTitleText("Axis Y");
                     chart->setTitle(" BarCateogry Y , Value X, title");
                     return chart;
                 }

demos/chartviewer/charts/axis/categoryaxis.cpp +2 -2

                 QChart *createChart(const DataTable &table)
                 {
                     QChart *chart = CategoryLineChart::createChart(table);
-                    chart->axisX()->setTitle("Axis X");
+                    chart->axisX()->setTitleText("Axis X");
-                    chart->axisY()->setTitle("Axis Y");
+                    chart->axisY()->setTitleText("Axis Y");
                     chart->setTitle("Category X , Category Y,title  ");
                     return chart;
                 }

demos/chartviewer/charts/axis/datetimeaxisx.cpp +2 -2

                 QChart *createChart(const DataTable &table)
                 {
                     QChart *chart = DateTimeAxisX::createChart(table);
-                    chart->axisX()->setTitle("Axis X");
+                    chart->axisX()->setTitleText("Axis X");
-                    chart->axisY()->setTitle("Axis Y");
+                    chart->axisY()->setTitleText("Axis Y");
                     chart->setTitle("DateTime X , Value Y, Title");
                     return chart;
                 }

demos/chartviewer/charts/axis/datetimeaxisy.cpp +2 -2

                 QChart *createChart(const DataTable &table)
                 {
                     QChart *chart = DateTimeAxisY::createChart(table);
-                    chart->axisX()->setTitle("Axis X");
+                    chart->axisX()->setTitleText("Axis X");
-                    chart->axisY()->setTitle("Axis Y");
+                    chart->axisY()->setTitleText("Axis Y");
                     chart->setTitle("Value X , DateTime Y, Title");
                     return chart;
                 }

demos/chartviewer/charts/axis/valueaxis.cpp +2 -2

                 QChart *createChart(const DataTable &table)
                 {
                     QChart *chart = ValueAxis::createChart(table);
-                    chart->axisX()->setTitle("Axis X");
+                    chart->axisX()->setTitleText("Axis X");
-                    chart->axisY()->setTitle("Axis Y");
+                    chart->axisY()->setTitleText("Axis Y");
                     chart->setTitle("Value X , Value Y, title");
                     return chart;
                 }

demos/chartviewer/charts/barseries/verticalpercentbarchart.cpp +1 -1

                 QChart *createChart(const DataTable &table)
                 {
                     QChart *chart = new QChart();
-                    chart->setTitle("Stacked bar chart");
+                    chart->setTitle("Percent bar chart");
                     QPercentBarSeries *series = new QPercentBarSeries(chart);
                     for (int i(0); i < table.count(); i++) {
                         QBarSet *set = new QBarSet("Bar set " + QString::number(i));

demos/chartviewer/charts/font/font.cpp +2 -2

                     chart->setTitleFont(font);
                     chart->axisX()->setLabelsFont(font);
                     chart->axisY()->setLabelsFont(font);
-                    chart->axisX()->setTitle("Axis X");
+                    chart->axisX()->setTitleText("Axis X");
-                    chart->axisY()->setTitle("Axis Y");
+                    chart->axisY()->setTitleText("Axis Y");
                     chart->axisX()->setTitleFont(font);
                     chart->axisY()->setTitleFont(font);
                     return chart;

demos/chartviewer/charts/multiaxis/multivalueaxis.cpp +4 -10

                         chart->addSeries(series);
                         axisX = new QValueAxis();
                         axisX->setLinePenColor(series->pen().color());
-                        if (nameIndex % 2)
-                            axisX->setAlignment(Qt::AlignTop);
-                        else
-                            axisX->setAlignment(Qt::AlignBottom);
                         axisY = new QValueAxis();
                         axisY->setLinePenColor(series->pen().color());
-                        if (nameIndex % 2)
+                        chart->addAxis(axisX,nameIndex % 2?Qt::AlignTop:Qt::AlignBottom);
-                            axisY->setAlignment(Qt::AlignRight);
+                        chart->addAxis(axisY,nameIndex % 2?Qt::AlignRight:Qt::AlignLeft);
-                        else
+                        series->attachAxis(axisX);
-                            axisY->setAlignment(Qt::AlignLeft);
+                        series->attachAxis(axisY);
-                        chart->setAxisX(axisX, series);
-                        chart->setAxisY(axisY, series);
                         nameIndex++;
                     }

demos/chartviewer/charts/multiaxis/multivalueaxis2.cpp +5 -11

                         chart->addSeries(series);
                         axisX = new QValueAxis();
                         axisX->setLinePenColor(series->pen().color());
-                        if (nameIndex % 2)
-                            axisX->setAlignment(Qt::AlignTop);
-                        else
-                            axisX->setAlignment(Qt::AlignBottom);
                         axisY = new QValueAxis();
                         axisY->setLinePenColor(series->pen().color());
-                        if (nameIndex % 2)
+                        chart->addAxis(axisX, nameIndex % 2?Qt::AlignTop:Qt::AlignBottom);
-                            axisY->setAlignment(Qt::AlignRight);
+                        chart->addAxis(axisY, nameIndex % 2?Qt::AlignRight:Qt::AlignLeft);
-                        else
+                        series->attachAxis(axisX);
-                            axisY->setAlignment(Qt::AlignLeft);
+                        series->attachAxis(axisY);
-                        chart->setAxisX(axisX, series);
-                        chart->setAxisY(axisY, series);
                         nameIndex++;
                     }

demos/chartviewer/charts/multiaxis/multivalueaxis3.cpp +6 -15

@@ -59,25 +59,16 public:
59	chart->addSeries(series);	59	chart->addSeries(series);
60	axisX = new QValueAxis();	60	axisX = new QValueAxis();
61	axisX->setLinePenColor(series->pen().color());	61	axisX->setLinePenColor(series->pen().color());
62	if (nameIndex % 2){	62	axisX->setTitleText("ValueAxis for series" + QString::number(nameIndex));
63	axisX->setAlignment(Qt::AlignTop);
64	} else{
65	axisX->setAlignment(Qt::AlignBottom);
66	}
67	axisX->setTitle("ValueAxis for series" + QString::number(nameIndex));
68		63
69	axisY = new QValueAxis();	64	axisY = new QValueAxis();
70	axisY->setLinePenColor(series->pen().color());	65	axisY->setLinePenColor(series->pen().color());
		66	axisY->setTitleText("ValueAxis for series" + QString::number(nameIndex));
71		67
72	if (nameIndex % 2){	68	chart->addAxis(axisX, nameIndex % 2?Qt::AlignTop:Qt::AlignBottom);
73	axisY->setAlignment(Qt::AlignRight);	69	chart->addAxis(axisY, nameIndex % 2?Qt::AlignRight:Qt::AlignLeft);
74	}else{	70	series->attachAxis(axisX);
75	axisY->setAlignment(Qt::AlignLeft);	71	series->attachAxis(axisY);
76	}
77	axisY->setTitle("ValueAxis for series" + QString::number(nameIndex));
78
79	chart->setAxisX(axisX, series);
80	chart->setAxisY(axisY, series);
81	nameIndex++;	72	nameIndex++;
82	}	73	}
83		74

demos/chartviewer/charts/multiaxis/multivalueaxis4.cpp +6 -13

@@ -59,22 +59,15 public:
59	chart->addSeries(series);	59	chart->addSeries(series);
60	axisX = new QValueAxis();	60	axisX = new QValueAxis();
61	axisX->setLinePenColor(series->pen().color());	61	axisX->setLinePenColor(series->pen().color());
62	axisX->setTitle("ValueAxis for series" + QString::number(nameIndex));	62	axisX->setTitleText("ValueAxis for series" + QString::number(nameIndex));
63	if (nameIndex % 2)
64	axisX->setAlignment(Qt::AlignTop);
65	else
66	axisX->setAlignment(Qt::AlignBottom);
67	axisY = new QValueAxis();	63	axisY = new QValueAxis();
68	axisY->setLinePenColor(series->pen().color());	64	axisY->setLinePenColor(series->pen().color());
69	axisY->setTitle("ValueAxis for series" + QString::number(nameIndex));	65	axisY->setTitleText("ValueAxis for series" + QString::number(nameIndex));
70		66
71	if (nameIndex % 2)	67	chart->addAxis(axisX, nameIndex % 2?Qt::AlignTop:Qt::AlignBottom);
72	axisY->setAlignment(Qt::AlignRight);	68	chart->addAxis(axisY, nameIndex % 2?Qt::AlignRight:Qt::AlignLeft);
73	else	69	series->attachAxis(axisX);
74	axisY->setAlignment(Qt::AlignLeft);	70	series->attachAxis(axisY);
75
76	chart->setAxisX(axisX, series);
77	chart->setAxisY(axisY, series);
78	nameIndex++;	71	nameIndex++;
79	}	72	}
80		73

demos/chartviewer/charts/multiaxis/multivaluebaraxis.cpp +8 -14

                         chart->addSeries(series);
                         axisX = new QValueAxis();
                         axisX->setLinePenColor(series->pen().color());
-                        axisX->setTitle("ValueAxis for series" + QString::number(nameIndex));
+                        axisX->setTitleText("ValueAxis for series" + QString::number(nameIndex));
-                        if (nameIndex % 2)
-                            axisX->setAlignment(Qt::AlignTop);
-                        else
-                            axisX->setAlignment(Qt::AlignBottom);
                         axisY = new QValueAxis();
                         axisY->setLinePenColor(series->pen().color());
-                        axisY->setTitle("ValueAxis for series" + QString::number(nameIndex));
+                        axisY->setTitleText("ValueAxis for series" + QString::number(nameIndex));
-                        if (nameIndex % 2)
-                            axisY->setAlignment(Qt::AlignRight);
-                        else
-                            axisY->setAlignment(Qt::AlignLeft);
-                        chart->setAxisX(axisX, series);
+                        chart->addAxis(axisX, nameIndex % 2?Qt::AlignTop:Qt::AlignBottom);
-                        chart->setAxisY(axisY, series);
+                        chart->addAxis(axisY, nameIndex % 2?Qt::AlignRight:Qt::AlignLeft);
+                        series->attachAxis(axisX);
+                        series->attachAxis(axisY);
                         nameIndex++;
                     }
                     barcategory->setLinePen(set->brush().color());
                     barcategory->setGridLinePen(set->brush().color());
-                    barcategory->setTitle("BarCategoryAxis Title");
+                    barcategory->setTitleText("BarCategoryAxis Title");
                     chart->setAxisX(barcategory, series);

examples/barchart/main.cpp +1 -1

                 QBarCategoryAxis *axis = new QBarCategoryAxis();
                 axis->append(categories);
                 chart->createDefaultAxes();
-                chart->setAxisX(axis, series);
+              //  chart->setAxisX(axis, series);
             //![4]
             //![5]

examples/datetimeaxis/main.cpp +2 -2

                 QDateTimeAxis *axisX = new QDateTimeAxis;
                 axisX->setTickCount(10);
                 axisX->setFormat("MMM yyyy");
-                axisX->setTitle("Date");
+                axisX->setTitleText("Date");
                 chart->setAxisX(axisX, series);
-                chart->axisY(series)->setTitle("Sunspots count");
+                chart->axisY(series)->setTitleText("Sunspots count");
                 //![4]
                 //![5]

examples/multiaxis/main.cpp +4 -13

                     axisX->setTickCount(7 + i);
                     axisX->setLinePenColor(series->pen().color());
-                    if (i % 2)
-                        axisX->setAlignment(Qt::AlignTop);
-                    else
-                        axisX->setAlignment(Qt::AlignBottom);
                     axisY = new QValueAxis;
                     axisY->setTickCount(7 + i);
                     axisY->setLinePenColor(series->pen().color());
-                    if (i % 2)
+                    chart->addAxis(axisX,i % 2?Qt::AlignTop:Qt::AlignBottom);
-                        axisY->setAlignment(Qt::AlignRight);
+                    chart->addAxis(axisY,i % 2?Qt::AlignRight:Qt::AlignLeft);
-                    else
+                    series->attachAxis(axisX);
-                        axisY->setAlignment(Qt::AlignLeft);
+                    series->attachAxis(axisY);
-                    chart->setAxisX(axisX, series);
-                    chart->setAxisY(axisY, series);
                 }
                 //![2]

examples/stackedbarchartdrilldown/drilldownchart.cpp +1 -1

                 createDefaultAxes();
                 setAxisX(axis, series);
-                axisY()->setTitle("Crops");
+                axisY()->setTitleText("Crops");
                 setTitle(series->name());
             }

examples/temperaturerecords/main.cpp +2 -2

                 QBarCategoryAxis *axis = new QBarCategoryAxis();
                 axis->append(categories);
-                axis->setTitle("Month");
+                axis->setTitleText("Month");
                 chart->createDefaultAxes();
                 chart->setAxisX(axis, series);
                 chart->axisY(series)->setRange(-52, 52);
-                chart->axisY(series)->setTitle(QString::fromUtf8("Temperature [\u00B0C]"));
+                chart->axisY(series)->setTitleText(QString::fromUtf8("Temperature [\u00B0C]"));
             //![4]
             //![5]

plugins/declarative/declarativechart.cpp +1 0

             #include "qcategoryaxis.h"
             #include "qabstractseries_p.h"
             #include "declarativemargins.h"
+            #include "chartdataset_p.h"
             #include "qchart_p.h"
             #ifndef QT_ON_ARM

src/areachart/areachartitem.cpp +30 -25

             //TODO: optimize : remove points which are not visible
-            AreaChartItem::AreaChartItem(QAreaSeries *areaSeries, ChartPresenter *presenter)
+            AreaChartItem::AreaChartItem(QAreaSeries *areaSeries, QGraphicsItem* item)
-                : ChartItem(presenter),
+                : ChartItem(areaSeries->d_func(),item), //TODO: fix me
                   m_series(areaSeries),
                   m_upper(0),
                   m_lower(0),
             {
                 setAcceptHoverEvents(true);
                 setZValue(ChartPresenter::LineChartZValue);
-                m_upper = new AreaBoundItem(this, m_series->upperSeries(), presenter);
+                m_upper = new AreaBoundItem(this, m_series->upperSeries());
                 if (m_series->lowerSeries())
-                    m_lower = new AreaBoundItem(this, m_series->lowerSeries(), presenter);
+                    m_lower = new AreaBoundItem(this, m_series->lowerSeries());
                 QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 delete m_lower;
             }
+            void AreaChartItem::setPresenter(ChartPresenter *presenter)
+            {
+                m_upper->setPresenter(presenter);
+                if (m_lower) {
+                    m_lower->setPresenter(presenter);
+                }
+            	ChartItem::setPresenter(presenter);
+            }
             QRectF AreaChartItem::boundingRect() const
             {
                 return m_rect;
             void AreaChartItem::updatePath()
             {
                 QPainterPath path;
+                QRectF rect(QPointF(0,0),domain()->size());
                 path = m_upper->path();
                 } else {
                     QPointF first = path.pointAtPercent(0);
                     QPointF last =  path.pointAtPercent(1);
-                    path.lineTo(last.x(), m_clipRect.bottom());
+                    path.lineTo(last.x(), rect.bottom());
-                    path.lineTo(first.x(), m_clipRect.bottom());
+                    path.lineTo(first.x(), rect.bottom());
                 }
                 path.closeSubpath();
                 prepareGeometryChange();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2 * m_pointPen.width());
                 setOpacity(m_series->opacity());
                 update();
             }
             void AreaChartItem::handleDomainUpdated()
             {
-                m_upper->setDomain(domain());
+            	Domain* d = m_upper->domain().data();
-                m_upper->handleDomainUpdated();
+            	d->setSize(domain()->size());
+            	d->setRange(domain()->minX(),domain()->maxX(),domain()->minY(),domain()->maxY());
+            	m_upper->handleDomainUpdated();
                 if (m_lower) {
-                    m_lower->setDomain(domain());
+                	Domain* d = m_lower->domain().data();
-                    m_lower->handleDomainUpdated();
+                	d->setSize(domain()->size());
+                	d->setRange(domain()->minX(),domain()->maxX(),domain()->minY(),domain()->maxY());
+                	m_lower->handleDomainUpdated();
                 }
             }
-            void AreaChartItem::handleGeometryChanged(const QRectF &rect)
-                m_clipRect = rect.translated(-rect.topLeft());
-                setPos(rect.topLeft());
-                m_upper->handleGeometryChanged(rect);
-                if (m_lower)
-                    m_lower->handleGeometryChanged(rect);
             void AreaChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(m_brush);
-                painter->setClipRect(m_clipRect);
+                painter->setClipRect(QRectF(QPointF(0,0),domain()->size()));
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                     painter->setPen(m_pointPen);
             void AreaChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
-                emit clicked(m_upper->calculateDomainPoint(event->pos()));
+                emit clicked(m_upper->domain()->calculateDomainPoint(event->pos()));
                 ChartItem::mousePressEvent(event);
             }
             void AreaChartItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
-                emit hovered(m_upper->calculateDomainPoint(event->pos()), true);
+                emit hovered(domain()->calculateDomainPoint(event->pos()), true);
                 event->accept();
             //    QGraphicsItem::hoverEnterEvent(event);
             }
             void AreaChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
-                emit hovered(m_upper->calculateDomainPoint(event->pos()), false);
+                emit hovered(domain()->calculateDomainPoint(event->pos()), false);
                 event->accept();
             //    QGraphicsItem::hoverEnterEvent(event);
             }

src/areachart/areachartitem_p.h +5 -7

             {
                 Q_OBJECT
             public:
-                AreaChartItem(QAreaSeries *areaSeries, ChartPresenter *presenter);
+                AreaChartItem(QAreaSeries *areaSeries, QGraphicsItem* item = 0);
                 ~AreaChartItem();
                 //from QGraphicsItem
                 void updatePath();
+                void setPresenter(ChartPresenter *presenter);
             protected:
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
             public Q_SLOTS:
                 void handleUpdated();
                 void handleDomainUpdated();
-                void handleGeometryChanged(const QRectF &size);
             private:
                 QAreaSeries *m_series;
                 LineChartItem *m_lower;
                 QPainterPath m_path;
                 QRectF m_rect;
-                QRectF m_clipRect;
                 QPen m_linePen;
                 QPen m_pointPen;
                 QBrush m_brush;
             class AreaBoundItem : public LineChartItem
             {
             public:
-                AreaBoundItem(AreaChartItem *item, QLineSeries *lineSeries, ChartPresenter *presenter)
+                AreaBoundItem(AreaChartItem *area, QLineSeries *lineSeries,QGraphicsItem* item = 0)
-                    : LineChartItem(lineSeries, 0), m_item(item)
+                    : LineChartItem(lineSeries, item), m_item(area)
                 {
-                    setPresenter(presenter);
                 }
                 ~AreaBoundItem() {}
                 void updateGeometry()
                 {
                     LineChartItem::updateGeometry();
                     m_item->updatePath();

src/areachart/qareaseries.cpp +60 -18

             #include "charttheme_p.h"
             #include "qvalueaxis.h"
             #include "qarealegendmarker.h"
+            #include "qchart_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QAreaSeries::~QAreaSeries()
             {
                 Q_D(QAreaSeries);
-                if (d->m_dataset)
+                if (d->m_chart)
-                    d->m_dataset->removeSeries(this);
+                    d->m_chart->removeSeries(this);
             }
             /*!
             void QAreaSeries::setUpperSeries(QLineSeries *series)
             {
                 Q_D(QAreaSeries);
-                d->m_upperSeries = series;
+                if(d->m_upperSeries!=series){
+                	d->m_upperSeries = series;
+                	//TODO:
+                }
             }
             QLineSeries *QAreaSeries::upperSeries() const
             {
             }
-            void QAreaSeriesPrivate::scaleDomain(Domain &domain)
+            void QAreaSeriesPrivate::initializeDomain()
             {
                 Q_Q(QAreaSeries);
-                qreal minX(domain.minX());
+                qreal minX(domain()->minX());
-                qreal minY(domain.minY());
+                qreal minY(domain()->minY());
-                qreal maxX(domain.maxX());
+                qreal maxX(domain()->maxX());
-                qreal maxY(domain.maxY());
+                qreal maxY(domain()->maxY());
                 QLineSeries *upperSeries = q->upperSeries();
                 QLineSeries *lowerSeries = q->lowerSeries();
                     }
                 }
-                domain.setRange(minX, maxX, minY, maxY);
+                domain()->setRange(minX, maxX, minY, maxY);
             }
-            ChartElement *QAreaSeriesPrivate::createGraphics(ChartPresenter *presenter)
+            void QAreaSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QAreaSeries);
+                AreaChartItem *area = new AreaChartItem(q,parent);
-                AreaChartItem *area = new AreaChartItem(q, presenter);
+                m_item.reset(area);
-                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
+                QAbstractSeriesPrivate::initializeGraphics(parent);
+            }
+            void  QAreaSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
+            {
+                Q_Q(QAreaSeries);
+                AreaChartItem *area = static_cast<AreaChartItem *>(m_item.data());
+                if (options.testFlag(QChart::SeriesAnimations)) {
                     area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem()));
                     if (q->lowerSeries())
-                        area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem()));
+                    area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem()));
+                }else{
+                    area->upperLineItem()->setAnimation(0);
+                    if (q->lowerSeries())
+                           area->lowerLineItem()->setAnimation(0);
                 }
-                presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
+                QAbstractSeriesPrivate::initializeAnimations(options);
-                return area;
             }
             QList<QLegendMarker*> QAreaSeriesPrivate::createLegendMarkers(QLegend* legend)
                 return list << new QAreaLegendMarker(q,legend);
             }
-            void QAreaSeriesPrivate::initializeAxis(QAbstractAxis *axis)
+            void QAreaSeriesPrivate::initializeAxes()
             {
-                Q_UNUSED(axis);
             }
             QAbstractAxis::AxisType QAreaSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
                 return QAbstractAxis::AxisTypeValue;
             }
+            QAbstractAxis* QAreaSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
+            {
+                Q_UNUSED(orientation);
+                return 0;
+            }
+            void QAreaSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
+            {
+                Q_Q(QAreaSeries);
+                QPen pen;
+                QBrush brush;
+                const QList<QGradient> gradients = theme->seriesGradients();
+                const QList<QColor> colors = theme->seriesColors();
+                if (forced || pen == m_pen) {
+                    pen.setColor(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0));
+                    pen.setWidthF(2);
+                    q->setPen(pen);
+                }
+                if (forced || brush == m_brush) {
+                    QBrush brush(colors.at(index % colors.size()));
+                    q->setBrush(brush);
+                }
+            }
             #include "moc_qareaseries.cpp"
             #include "moc_qareaseries_p.cpp"

src/areachart/qareaseries_p.h +8 -4

             public:
                 QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries, QAreaSeries *q);
-                void scaleDomain(Domain &domain);
+                void initializeDomain();
-                ChartElement *createGraphics(ChartPresenter *presenter);
+                void initializeAxes();
-                QList<QLegendMarker*> createLegendMarkers(QLegend* legend);
+                void initializeGraphics(QGraphicsItem* parent);
-                void initializeAxis(QAbstractAxis *axis);
+                void initializeTheme(int index, ChartTheme* theme, bool forced = false);
+                void initializeAnimations(QChart::AnimationOptions options);
+                QList<QLegendMarker *> createLegendMarkers(QLegend *legend);
                 QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const;
+                QAbstractAxis* createDefaultAxis(Qt::Orientation) const;
             Q_SIGNALS:
                 void updated();

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

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartBarCategoryAxisX::ChartBarCategoryAxisX(QBarCategoryAxis *axis, ChartPresenter *presenter)
+            ChartBarCategoryAxisX::ChartBarCategoryAxisX(QBarCategoryAxis *axis, QGraphicsItem* item)
-                : HorizontalAxis(axis, presenter, true),
+                : HorizontalAxis(axis, item, true),
                   m_categoriesAxis(axis)
             {
             void ChartBarCategoryAxisX::handleAxisUpdated()
             {
+            	//TODO:
+            	/*
                 if (m_categoriesAxis->categories() != m_categories) {
                     m_categories = m_categoriesAxis->categories();
                     if (ChartAxis::layout().count() == m_categoriesAxis->d_ptr->count() + 2)
                         updateGeometry();
                 }
-                ChartAxis::handleAxisUpdated();
+                */
+                //TODO: ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartBarCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const

src/axis/barcategoryaxis/chartbarcategoryaxisx_p.h +1 -1

             class ChartBarCategoryAxisX : public HorizontalAxis
             {
             public:
-                ChartBarCategoryAxisX(QBarCategoryAxis *axis, ChartPresenter *presenter);
+                ChartBarCategoryAxisX(QBarCategoryAxis *axis, QGraphicsItem* item = 0);
                 ~ChartBarCategoryAxisX();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;

src/axis/barcategoryaxis/chartbarcategoryaxisy.cpp +6 -5

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartBarCategoryAxisY::ChartBarCategoryAxisY(QBarCategoryAxis *axis, ChartPresenter *presenter)
+            ChartBarCategoryAxisY::ChartBarCategoryAxisY(QBarCategoryAxis *axis, QGraphicsItem* item)
-                : VerticalAxis(axis, presenter, true),
+                : VerticalAxis(axis, item, true),
                   m_categoriesAxis(axis)
             {
             }
             void ChartBarCategoryAxisY::handleAxisUpdated()
             {
+            	//TODO:
+            	/*
                 if (m_categoriesAxis->categories() != m_categories) {
                     m_categories = m_categoriesAxis->categories();
                     if (ChartAxis::layout().count() == m_categoriesAxis->d_ptr->count() + 2)
                         updateGeometry();
+                }*/
-                ChartAxis::handleAxisUpdated();
+                //TODO :: ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartBarCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const

src/axis/barcategoryaxis/chartbarcategoryaxisy_p.h +1 -1

             class ChartBarCategoryAxisY : public VerticalAxis
             {
             public:
-                ChartBarCategoryAxisY(QBarCategoryAxis *axis, ChartPresenter *presenter);
+                ChartBarCategoryAxisY(QBarCategoryAxis *axis, QGraphicsItem* item = 0);
                 ~ChartBarCategoryAxisY();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;

src/axis/barcategoryaxis/qbarcategoryaxis.cpp +103 -81

@@ -23,7 +23,7
23	#include "chartbarcategoryaxisx_p.h"	23	#include "chartbarcategoryaxisx_p.h"
24	#include "chartbarcategoryaxisy_p.h"	24	#include "chartbarcategoryaxisy_p.h"
25	#include "domain_p.h"	25	#include "domain_p.h"
26	#include "chart~~dataset_p~~.h"	26	#include "qchart.h"
27	#include <qmath.h>	27	#include <qmath.h>
28		28
29	QTCOMMERCIALCHART_BEGIN_NAMESPACE	29	QTCOMMERCIALCHART_BEGIN_NAMESPACE
@@ -87,7 +87,8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
87	Defines the minimum value on the axis.	87	Defines the minimum value on the axis.
88	*/	88	*/
89	/*!	89	/*!
90	\qmlproperty QString Bar~~CategoryAxis::min~~	90	\qmlproperty QString Bar if (d->m_chart)
		91	d->m_chart->removeAxis(this);CategoryAxis::min
91	Defines the minimum value on the axis.	92	Defines the minimum value on the axis.
92	*/	93	*/
93		94
@@ -160,8 +161,8 QBarCategoryAxis::QBarCategoryAxis(QObject *parent):
160	QBarCategoryAxis::~QBarCategoryAxis()	161	QBarCategoryAxis::~QBarCategoryAxis()
161	{	162	{
162	Q_D(QBarCategoryAxis);	163	Q_D(QBarCategoryAxis);
163	if (d->m_~~datase~~t)	164	if (d->m_chart)
164	d->m_~~datase~~t->removeAxis(this);	165	d->m_chart->removeAxis(this);
165	}	166	}
166		167
167	/*!	168	/*!
@@ -248,7 +249,7 void QBarCategoryAxis::remove(const QString &category)
248	setRange(d->m_minCategory, d->m_categories.last());	249	setRange(d->m_minCategory, d->m_categories.last());
249	} else {	250	} else {
250	d->updateCategoryDomain();	251	d->updateCategoryDomain();
251	d->emitUpdated();	252	//TODO:: d->emitUpdated();
252	}	253	}
253	} else {	254	} else {
254	setRange(QString::null, QString::null);	255	setRange(QString::null, QString::null);
@@ -282,7 +283,7 void QBarCategoryAxis::insert(int index, const QString &category)
282	setRange(d->m_minCategory, d->m_categories.last());	283	setRange(d->m_minCategory, d->m_categories.last());
283	} else {	284	} else {
284	d->updateCategoryDomain();	285	d->updateCategoryDomain();
285	d->emitUpdated();	286	//TODO:: d->emitUpdated();
286	}	287	}
287		288
288	emit categoriesChanged();	289	emit categoriesChanged();
@@ -307,7 +308,7 void QBarCategoryAxis::replace(const QString &oldCategory, const QString &newCat
307	} else if (d->m_maxCategory == oldCategory) {	308	} else if (d->m_maxCategory == oldCategory) {
308	setRange(d->m_minCategory, newCategory);	309	setRange(d->m_minCategory, newCategory);
309	} else {	310	} else {
310	d->emitUpdated();	311	//TODO:: d->emitUpdated();
311	}	312	}
312	emit categoriesChanged();	313	emit categoriesChanged();
313	emit countChanged();	314	emit countChanged();
@@ -375,7 +376,7 QString QBarCategoryAxis::at(int index) const
375	void QBarCategoryAxis::setMin(const QString &min)	376	void QBarCategoryAxis::setMin(const QString &min)
376	{	377	{
377	Q_D(QBarCategoryAxis);	378	Q_D(QBarCategoryAxis);
378	setRange(min, d->m_maxCategory);	379	d->setRange(min, d->m_maxCategory);
379	}	380	}
380		381
381	/*!	382	/*!
@@ -393,7 +394,7 QString QBarCategoryAxis::min() const
393	void QBarCategoryAxis::setMax(const QString &max)	394	void QBarCategoryAxis::setMax(const QString &max)
394	{	395	{
395	Q_D(QBarCategoryAxis);	396	Q_D(QBarCategoryAxis);
396	setRange(d->m_minCategory, max);	397	d->setRange(d->m_minCategory, max);
397	}	398	}
398		399
399	/*!	400	/*!
@@ -411,44 +412,7 QString QBarCategoryAxis::max() const
411	void QBarCategoryAxis::setRange(const QString &minCategory, const QString &maxCategory)	412	void QBarCategoryAxis::setRange(const QString &minCategory, const QString &maxCategory)
412	{	413	{
413	Q_D(QBarCategoryAxis);	414	Q_D(QBarCategoryAxis);
414		415	d->setRange(minCategory,maxCategory);
415	bool changed = false;
416
417	//special case in case or clearing all categories
418	if (minCategory.isNull() && maxCategory.isNull()) {
419	d->m_minCategory = minCategory;
420	d->m_maxCategory = maxCategory;
421	d->m_min = 0;
422	d->m_max = 0;
423	emit minChanged(minCategory);
424	emit maxChanged(maxCategory);
425	d->m_count = 0;
426	emit rangeChanged(d->m_minCategory, d->m_maxCategory);
427	d->emitUpdated();
428	}
429
430	if (d->m_categories.indexOf(maxCategory) < d->m_categories.indexOf(minCategory))
431	return;
432
433	if (!minCategory.isEmpty() && d->m_minCategory != minCategory && d->m_categories.contains(minCategory)) {
434	d->m_minCategory = minCategory;
435	d->m_min = d->m_categories.indexOf(d->m_minCategory) - 0.5;
436	changed = true;
437	emit minChanged(minCategory);
438	}
439
440	if (!maxCategory.isEmpty() && d->m_maxCategory != maxCategory && d->m_categories.contains(maxCategory)) {
441	d->m_maxCategory = maxCategory;
442	d->m_max = d->m_categories.indexOf(d->m_maxCategory) + 0.5;
443	changed = true;
444	emit maxChanged(maxCategory);
445	}
446
447	if (changed) {
448	d->m_count = d->m_max - d->m_min;
449	emit rangeChanged(d->m_minCategory, d->m_maxCategory);
450	d->emitUpdated();
451	}
452	}	416	}
453		417
454	/*!	418	/*!
@@ -487,55 +451,114 void QBarCategoryAxisPrivate::setMax(const QVariant &max)
487		451
488	void QBarCategoryAxisPrivate::setRange(const QVariant &min, const QVariant &max)	452	void QBarCategoryAxisPrivate::setRange(const QVariant &min, const QVariant &max)
489	{	453	{
490	Q_Q(QBarCategoryAxis);
491	QString value1 = min.toString();	454	QString value1 = min.toString();
492	QString value2 = max.toString();	455	QString value2 = max.toString();
493	q->setRange(value1, value2);	456	setRange(value1, value2);
494	}	457	}
495		458
496	void QBarCategoryAxisPrivate::~~handleDomainUpdated~~()	459	void QBarCategoryAxisPrivate::setRange(qreal min, qreal max)
497	{	460	{
498	Q_Q(QBarCategoryAxis);	461	Q_Q(QBarCategoryAxis);
499	Domain domain = qobject_cast<Domain >(sender());
500
501	if (m_orientation == Qt::Horizontal) {
502	m_min = domain->minX();
503	m_max = domain->maxX();
504	} else if (m_orientation == Qt::Vertical) {
505	m_min = domain->minY();
506	m_max = domain->maxY();
507	}
508		462
		463	bool categoryChanged = false;
509	bool changed = false;	464	bool changed = false;
510		465
511	int min = m_min + 0.5;	466	if (min > max)
512	if (min >= 0 && min < m_categories.count()) {	467	return;
513	QString minCategory = m_categories.at(min);	468
514	if (m_minCategory != minCategory && !minCategory.isEmpty()) {	469	if (!qFuzzyIsNull(m_min - min)) {
515	m_min~~Category~~ = min~~Category~~;	470	m_min = min;
516	changed = true;	471	changed = true;
517	emit q->minChanged(minCategory);	472
		473	int imin = m_min + 0.5;
		474	if (imin >= 0 && imin < m_categories.count()) {
		475	QString minCategory = m_categories.at(imin);
		476	if (m_minCategory != minCategory && !minCategory.isEmpty()) {
		477	m_minCategory = minCategory;
		478	categoryChanged = true;
		479	emit q->minChanged(minCategory);
		480	}
518	}	481	}
		482
519	}	483	}
520	int max = m_max - 0.5;	484
521	if (max >= 0 && max < m_categories.count()) {	485	if (!qFuzzyIsNull(m_max - max)) {
522	QString maxCategory = m_categories.at(max);	486	m_max = max;
523	if (m_maxCategory != maxCategory && !maxCategory.isEmpty()) {	487	changed = true;
524	m_maxCategory = maxCategory;	488
525	emit q->maxChanged(maxCategory);	489	int imax = m_max - 0.5;
		490	if (imax >= 0 && imax < m_categories.count()) {
		491	QString maxCategory = m_categories.at(imax);
		492	if (m_maxCategory != maxCategory && !maxCategory.isEmpty()) {
		493	m_maxCategory = maxCategory;
		494	categoryChanged = true;
		495	emit q->maxChanged(maxCategory);
		496	}
526	}	497	}
527	}	498	}
528		499
529	if (changed)	500	if (categoryChanged){
530	emit q->rangeChanged(m_minCategory, m_maxCategory);	501	emit q->rangeChanged(m_minCategory, m_maxCategory);
		502	}
		503
		504	if (changed) {
		505	emit rangeChanged(m_min,m_max);
		506	}
531	}	507	}
532		508
533	ChartAxis QBarCategoryAxisPrivate::createGraphics(ChartPresenter presenter)	509	void QBarCategoryAxisPrivate::setRange(const QString &minCategory, const QString &maxCategory)
		510	{
		511	Q_Q(QBarCategoryAxis);
		512	bool changed = false;
		513
		514	//special case in case or clearing all categories
		515	if (minCategory.isNull() && maxCategory.isNull()) {
		516	m_minCategory = minCategory;
		517	m_maxCategory = maxCategory;
		518	m_min = 0;
		519	m_max = 0;
		520	m_count = 0;
		521	emit q->minChanged(minCategory);
		522	emit q->maxChanged(maxCategory);
		523	emit q->rangeChanged(m_minCategory, m_maxCategory);
		524	emit rangeChanged(m_min,m_max);
		525	}
		526
		527	if (m_categories.indexOf(maxCategory) < m_categories.indexOf(minCategory))
		528	return;
		529
		530	if (!minCategory.isEmpty() && m_minCategory != minCategory && m_categories.contains(minCategory)) {
		531	m_minCategory = minCategory;
		532	m_min = m_categories.indexOf(m_minCategory) - 0.5;
		533	changed = true;
		534	emit q->minChanged(minCategory);
		535	}
		536
		537	if (!maxCategory.isEmpty() && m_maxCategory != maxCategory && m_categories.contains(maxCategory)) {
		538	m_maxCategory = maxCategory;
		539	m_max = m_categories.indexOf(m_maxCategory) + 0.5;
		540	changed = true;
		541	emit q->maxChanged(maxCategory);
		542	}
		543
		544	if (changed) {
		545	m_count = m_max - m_min;
		546	emit q->rangeChanged(m_minCategory, m_maxCategory);
		547	emit rangeChanged(m_min,m_max);
		548	}
		549	}
		550
		551	void QBarCategoryAxisPrivate::initializeGraphics(QGraphicsItem* parent)
534	{	552	{
535	Q_Q(QBarCategoryAxis);	553	Q_Q(QBarCategoryAxis);
536	if (m_orientation == Qt::Vertical)	554	ChartAxis* axis(0);
537	return new ChartBarCategoryAxisY(q, presenter);	555	if (orientation() == Qt::Vertical)
538	~~return~~ new ChartBarCategoryAxisX(q, presenter);	556	axis = new ChartBarCategoryAxisY(q,parent);
		557	if (orientation() == Qt::Horizontal)
		558	axis = new ChartBarCategoryAxisX(q,parent);
		559
		560	m_item.reset(axis);
		561	QAbstractAxisPrivate::initializeGraphics(parent);
539	}	562	}
540		563
541	void QBarCategoryAxisPrivate::updateCategoryDomain()	564	void QBarCategoryAxisPrivate::updateCategoryDomain()
@@ -546,14 +569,13 void QBarCategoryAxisPrivate::updateCategoryDomain()
546	}	569	}
547		570
548		571
549	void QBarCategoryAxisPrivate::intializeDomain(Domain *domain)	572	void QBarCategoryAxisPrivate::initializeDomain(Domain *domain)
550	{	573	{
551
552	Q_Q(QBarCategoryAxis);	574	Q_Q(QBarCategoryAxis);
553	if (m_max == m_min) {	575	if (m_max == m_min) {
554	int min;	576	int min;
555	int max;	577	int max;
556	if (m_orientation == Qt::Vertical) {	578	if (orientation() == Qt::Vertical) {
557	min = domain->minY() + 0.5;	579	min = domain->minY() + 0.5;
558	max = domain->maxY() - 0.5;	580	max = domain->maxY() - 0.5;
559	} else {	581	} else {
@@ -564,7 +586,7 void QBarCategoryAxisPrivate::intializeDomain(Domain *domain)
564	if (min > 0 && min < m_categories.count() && max > 0 && max < m_categories.count())	586	if (min > 0 && min < m_categories.count() && max > 0 && max < m_categories.count())
565	q->setRange(m_categories.at(min), m_categories.at(max));	587	q->setRange(m_categories.at(min), m_categories.at(max));
566	} else {	588	} else {
567	if (m_orientation == Qt::Vertical)	589	if (orientation() == Qt::Vertical)
568	domain->setRangeY(m_min, m_max);	590	domain->setRangeY(m_min, m_max);
569	else	591	else
570	domain->setRangeX(m_min, m_max);	592	domain->setRangeX(m_min, m_max);

src/axis/barcategoryaxis/qbarcategoryaxis_p.h +11 -7

                 ~QBarCategoryAxisPrivate();
             public:
-                ChartAxis *createGraphics(ChartPresenter *presenter);
+                void initializeGraphics(QGraphicsItem* parent);
-                void intializeDomain(Domain *domain);
+                void initializeDomain(Domain *domain);
-                void handleDomainUpdated();
                 void updateCategoryDomain();
+                //interface for manipulating range form base class
+                void setRange(const QVariant &min, const QVariant &max);
+                void setMin(const QVariant &min);
+                void setMax(const QVariant &max);
+                //interface manipulating range form domain
                 qreal min() { return m_min; }
                 qreal max() { return m_max; }
-                int count() const { return m_count; }
+                void setRange(qreal min,qreal max);
             private:
                 //range handling
-                void setMin(const QVariant &min);
+                void setRange(const QString &minCategory, const QString &maxCategory);
-                void setMax(const QVariant &max);
-                void setRange(const QVariant &min, const QVariant &max);
             private:
                 QStringList m_categories;

src/axis/categoryaxis/chartcategoryaxisx.cpp +3 -3

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartCategoryAxisX::ChartCategoryAxisX(QCategoryAxis *axis, ChartPresenter *presenter)
+            ChartCategoryAxisX::ChartCategoryAxisX(QCategoryAxis *axis, QGraphicsItem* item)
-                : HorizontalAxis(axis, presenter, true),
+                : HorizontalAxis(axis, item, true),
                   m_axis(axis)
             {
             }
             void ChartCategoryAxisX::handleAxisUpdated()
             {
                 updateGeometry();
-                ChartAxis::handleAxisUpdated();
+                //TODO :: ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const

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

             class ChartCategoryAxisX : public HorizontalAxis
             {
             public:
-                ChartCategoryAxisX(QCategoryAxis *axis, ChartPresenter *presenter);
+                ChartCategoryAxisX(QCategoryAxis *axis, QGraphicsItem* item = 0);
                 ~ChartCategoryAxisX();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;

src/axis/categoryaxis/chartcategoryaxisy.cpp +3 -3

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartCategoryAxisY::ChartCategoryAxisY(QCategoryAxis *axis, ChartPresenter *presenter)
+            ChartCategoryAxisY::ChartCategoryAxisY(QCategoryAxis *axis, QGraphicsItem* item)
-                : VerticalAxis(axis, presenter, true),
+                : VerticalAxis(axis, item, true),
                   m_axis(axis)
             {
             }
             void ChartCategoryAxisY::handleAxisUpdated()
             {
                 updateGeometry();
-                ChartAxis::handleAxisUpdated();
+                //TODO:: ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const

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

             class ChartCategoryAxisY : public VerticalAxis
             {
             public:
-                ChartCategoryAxisY(QCategoryAxis *axis, ChartPresenter *presenter);
+                ChartCategoryAxisY(QCategoryAxis *axis, QGraphicsItem* item = 0);
                 ~ChartCategoryAxisY();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;

src/axis/categoryaxis/qcategoryaxis.cpp +15 -13

             #include "qcategoryaxis_p.h"
             #include "chartcategoryaxisx_p.h"
             #include "chartcategoryaxisy_p.h"
+            #include "qchart.h"
             #include <qmath.h>
             #include <QDebug>
             */
             QCategoryAxis::~QCategoryAxis()
             {
+                Q_D(QCategoryAxis);
+                if (d->m_chart)
+                    d->m_chart->removeAxis(this);
             }
             /*!
                             d->m_categoriesMap.insert(label, range);
                         }
                     }
-                    d->emitUpdated();
+                    //TODO:: d->emitUpdated();
                 }
             }
                     Range range = d->m_categoriesMap.value(oldLabel);
                     d->m_categoriesMap.remove(oldLabel);
                     d->m_categoriesMap.insert(newLabel, range);
-                    d->emitUpdated();
+                    //TODO:: d->emitUpdated();
                 }
             }
                 return m_categories.count() + 1;
             }
-            void QCategoryAxisPrivate::handleAxisRangeChanged(qreal min, qreal max, int count)
+            void QCategoryAxisPrivate::initializeGraphics(QGraphicsItem* parent)
-                Q_UNUSED(count);
-                Q_UNUSED(min);
-                Q_UNUSED(max);
-            ChartAxis *QCategoryAxisPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QCategoryAxis);
-                if (m_orientation == Qt::Vertical)
+                ChartAxis* axis(0);
-                    return new ChartCategoryAxisY(q, presenter);
+                if (orientation() == Qt::Vertical)
-                return new ChartCategoryAxisX(q, presenter);
+                    axis = new ChartCategoryAxisY(q,parent);
+                else if(orientation() == Qt::Horizontal)
+                    axis = new ChartCategoryAxisX(q,parent);
+                m_item.reset(axis);
+                QAbstractAxisPrivate::initializeGraphics(parent);
             }
             #include "moc_qcategoryaxis.cpp"

src/axis/categoryaxis/qcategoryaxis_p.h +1 -4

                 QCategoryAxisPrivate(QCategoryAxis *q);
                 ~QCategoryAxisPrivate();
-                ChartAxis *createGraphics(ChartPresenter *presenter);
+                void initializeGraphics(QGraphicsItem* parent);
                 int ticksCount() const;
             Q_SIGNALS:
                 void changed(qreal min, qreal max, int tickCount, bool niceNumbers);
-            public Q_SLOTS:
-                void handleAxisRangeChanged(qreal min, qreal max, int count);
             private:
                 QMap<QString , Range> m_categoriesMap;
                 QStringList m_categories;

src/axis/chartaxis.cpp +183 -208

@@ -32,34 +32,56
32		32
33	QTCOMMERCIALCHART_BEGIN_NAMESPACE	33	QTCOMMERCIALCHART_BEGIN_NAMESPACE
34		34
35	ChartAxis::ChartAxis(QAbstractAxis axis, ~~ChartPresenter~~ ~~presenter~~, bool intervalAxis)	35	ChartAxis::ChartAxis(QAbstractAxis axis, QGraphicsItem item , bool intervalAxis)
36	: ChartElement(~~presenter~~),	36	: ChartElement(item),
37	m_cha~~rtA~~xis(axis),	37	m_axis(axis),
38	m_labelsAngle(0),	38	m_labelsAngle(0),
39	m_grid(new QGraphicsItemGroup(~~presenter~~->~~rootItem~~())),	39	m_grid(new QGraphicsItemGroup(item)),
40	m_~~shades~~(new QGraphicsItemGroup(~~presenter~~->~~rootItem~~())),	40	m_arrow(new QGraphicsItemGroup(item)),
41	m_~~label~~s(new QGraphicsItemGroup(~~presenter~~->~~rootItem~~())),	41	m_shades(new QGraphicsItemGroup(item)),
42	m_~~arrow~~(new QGraphicsItemGroup(~~presenter~~->~~rootItem~~())),	42	m_labels(new QGraphicsItemGroup(item)),
43	m_title(new QGraphicsSimpleTextItem(~~presenter~~->~~rootItem~~())),	43	m_title(new QGraphicsSimpleTextItem(item)),
44	m_min(0),
45	m_max(0),
46	m_animation(0),	44	m_animation(0),
47	m_labelPadding(5),	45	m_labelPadding(5),
48	m_intervalAxis(intervalAxis)	46	m_intervalAxis(intervalAxis)
49	{	47	{
		48	Q_ASSERT(item);
50	//initial initialization	49	//initial initialization
51	m_arrow->setZValue(ChartPresenter::AxisZValue);
52	m_arrow->setHandlesChildEvents(false);	50	m_arrow->setHandlesChildEvents(false);
		51	m_arrow->setZValue(ChartPresenter::AxisZValue);
		52	m_arrow->setVisible(m_axis->isLineVisible());
53	m_labels->setZValue(ChartPresenter::AxisZValue);	53	m_labels->setZValue(ChartPresenter::AxisZValue);
		54	m_labels->setVisible(m_axis->labelsVisible());
54	m_shades->setZValue(ChartPresenter::ShadesZValue);	55	m_shades->setZValue(ChartPresenter::ShadesZValue);
		56	m_shades->setVisible(m_axis->shadesVisible());
55	m_grid->setZValue(ChartPresenter::GridZValue);	57	m_grid->setZValue(ChartPresenter::GridZValue);
		58	m_grid->setVisible(m_axis->isGridLineVisible());
56	m_title->setZValue(ChartPresenter::GridZValue);	59	m_title->setZValue(ChartPresenter::GridZValue);
		60	connectSlots();
57		61
58	QObject::connect(m_chartAxis->d_ptr.data(), SIGNAL(updated()), this, SLOT(handleAxisUpdated()));	62	setFlag(QGraphicsItem::ItemHasNoContents,true);
59		63	}
60	QGraphicsSimpleTextItem item;
61	m_font = item.font();
62		64
		65	void ChartAxis::connectSlots()
		66	{
		67	QObject::connect(m_axis,SIGNAL(visibleChanged(bool)),this,SLOT(handleVisibleChanged(bool)));
		68	QObject::connect(m_axis,SIGNAL(lineVisibleChanged(bool)),this,SLOT(handleArrowVisibleChanged(bool)));
		69	QObject::connect(m_axis,SIGNAL(gridLineVisibleChanged(bool)),this,SLOT(handleGridVisibleChanged(bool)));
		70	QObject::connect(m_axis,SIGNAL(labelsVisibleChanged(bool)),this,SLOT(handleLabelsVisibleChanged(bool)));
		71	QObject::connect(m_axis,SIGNAL(shadesVisibleChanged(bool)),this,SLOT(handleShadesVisibleChanged(bool)));
		72	QObject::connect(m_axis,SIGNAL(labelsAngleChanged(int)),this,SLOT(handleLabelsAngleChanged(int)));
		73	QObject::connect(m_axis,SIGNAL(linePenChanged(const QPen&)),this,SLOT(handleArrowPenChanged(const QPen&)));
		74	QObject::connect(m_axis,SIGNAL(labelsPenChanged(const QPen&)),this,SLOT(handleLabelsPenChanged(const QPen&)));
		75	QObject::connect(m_axis,SIGNAL(labelsBrushChanged(const QBrush&)),this,SLOT(handleLabelsBrushChanged(const QBrush&)));
		76	QObject::connect(m_axis,SIGNAL(labelsFontChanged(const QFont&)),this,SLOT(handleLabelsFontChanged(const QFont&)));
		77	QObject::connect(m_axis,SIGNAL(gridLinePenChanged(const QPen&)),this,SLOT(handleGridPenChanged(const QPen&)));
		78	QObject::connect(m_axis,SIGNAL(shadesPenChanged(const QPen&)),this,SLOT(handleShadesPenChanged(const QPen&)));
		79	QObject::connect(m_axis,SIGNAL(shadesBrushChanged(const QBrush&)),this,SLOT(handleShadesBrushChanged(const QBrush&)));
		80	QObject::connect(m_axis,SIGNAL(titleTextChanged(const QString&)),this,SLOT(handleTitleTextChanged(const QString&)));
		81	QObject::connect(m_axis,SIGNAL(titleFontChanged(const QFont&)),this,SLOT(handleTitleFontChanged(const QFont&)));
		82	QObject::connect(m_axis,SIGNAL(titlePenChanged(const QPen&)),this,SLOT(handleTitlePenChanged(const QPen&)));
		83	QObject::connect(m_axis,SIGNAL(titleBrushChanged(const QBrush&)),this,SLOT(handleTitleBrushChanged(const QBrush&)));
		84	QObject::connect(m_axis->d_ptr.data(),SIGNAL(rangeChanged(qreal,qreal)),this,SLOT(handleRangeChanged(qreal,qreal)));
63	}	85	}
64		86
65	ChartAxis::~ChartAxis()	87	ChartAxis::~ChartAxis()
@@ -78,23 +100,41 void ChartAxis::setLayout(QVector<qreal> &layout)
78		100
79	void ChartAxis::createItems(int count)	101	void ChartAxis::createItems(int count)
80	{	102	{
81	if (m_arrow->child~~Items~~().size() == 0)	103	if (m_arrow->children().size() == 0){
82	m_arrow->addToGroup(new AxisItem(this, presenter()->rootItem()));	104	QGraphicsLineItem* arrow = new ArrowItem(this, this);
		105	arrow->setPen(m_axis->linePen());
		106	m_arrow->addToGroup(arrow);
		107	}
83		108
84	if (m_intervalAxis && m_grid->child~~Items~~().size() == 0) {	109	if (m_intervalAxis && m_grid->children().size() == 0) {
85	for (int i = 0 ; i < 2 ; i ++)	110	for (int i = 0 ; i < 2 ; i ++){
86	m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));	111	QGraphicsLineItem* item = new QGraphicsLineItem(this);
		112	item->setPen(m_axis->gridLinePen());
		113	m_grid->addToGroup(item);
		114	}
87	}	115	}
88		116
89	for (int i = 0; i < count; ++i) {	117	for (int i = 0; i < count; ++i) {
90	m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));	118	QGraphicsLineItem* arrow = new QGraphicsLineItem(this);
91	QGraphicsSimpleTextItem *label = new QGraphicsSimpleTextItem(presenter()->rootItem());	119	arrow->setPen(m_axis->linePen());
92	label->setFont(m_font);	120	QGraphicsLineItem* grid = new QGraphicsLineItem(this);
		121	grid->setPen(m_axis->gridLinePen());
		122	QGraphicsSimpleTextItem* label = new QGraphicsSimpleTextItem(this);
		123	label->setFont(m_axis->labelsFont());
		124	label->setPen(m_axis->labelsPen());
		125	label->setBrush(m_axis->labelsBrush());
		126	m_arrow->addToGroup(arrow);
		127	m_grid->addToGroup(grid);
93	m_labels->addToGroup(label);	128	m_labels->addToGroup(label);
94	m_arrow->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));	129
95	if ((m_grid->childItems().size()) % 2 && m_grid->childItems().size() > 2)	130	if ((m_grid->childItems().size()) % 2 && m_grid->childItems().size() > 2){
96	m_shades->addToGroup(new QGraphicsRectItem(presenter()->rootItem()));	131	QGraphicsRectItem* shades = new QGraphicsRectItem(this);
		132	shades->setPen(m_axis->shadesPen());
		133	shades->setBrush(m_axis->shadesBrush());
		134	m_shades->addToGroup(shades);
		135	}
97	}	136	}
		137
98	}	138	}
99		139
100	void ChartAxis::deleteItems(int count)	140	void ChartAxis::deleteItems(int count)
@@ -122,8 +162,6 void ChartAxis::updateLayout(QVector<qreal> &layout)
122	else if (diff < 0)	162	else if (diff < 0)
123	createItems(-diff);	163	createItems(-diff);
124		164
125	if (diff < 0) handleAxisUpdated();
126
127	if (m_animation) {	165	if (m_animation) {
128	switch (presenter()->state()) {	166	switch (presenter()->state()) {
129	case ChartPresenter::ZoomInState:	167	case ChartPresenter::ZoomInState:
@@ -154,67 +192,103 void ChartAxis::updateLayout(QVector<qreal> &layout)
154	}	192	}
155	}	193	}
156		194
157	void ChartAxis::setArrowOpacity(qreal opacity)	195	void ChartAxis::setLabelPadding(int padding)
		196	{
		197	m_labelPadding = padding;
		198	}
		199
		200	bool ChartAxis::isEmpty()
		201	{
		202	return m_axisRect.isEmpty() \|\| m_gridRect.isEmpty() \|\| qFuzzyCompare(min(),max());
		203	}
		204
		205	void ChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
		206	{
		207	m_gridRect = grid;
		208	m_axisRect = axis;
		209
		210	if (isEmpty())
		211	return;
		212
		213	QVector<qreal> layout = calculateLayout();
		214	updateLayout(layout);
		215	}
		216
		217	qreal ChartAxis::min() const
158	{	218	{
159	m_arrow->setOpacity(opacity);	219	return m_axis->d_ptr->min();
160	}	220	}
161		221
162	qreal ChartAxis::~~arrowOpacity~~() const	222	qreal ChartAxis::max() const
163	{	223	{
164	return m_arrow->opacity();	224	return m_axis->d_ptr->max();
165	}	225	}
166		226
167	void ChartAxis::setArrowVisibility(bool visible)	227	QFont ChartAxis::font() const
168	{	228	{
169	m_arrow->setOpacity(visible);	229	return m_axis->labelsFont();
170	}	230	}
171		231
172	void ChartAxis::setGridOpacity(qreal opacity)	232	QFont ChartAxis::titleFont() const
173	{	233	{
174	m_grid->setOpacity(opacity);	234	return m_axis->titleFont();
175	}	235	}
176		236
177	~~qreal~~ ChartAxis::~~gridOpacity~~() const	237	QString ChartAxis::titleText() const
178	{	238	{
179	return m_grid->opacity();	239	return m_axis->titleText();
180	}	240	}
181		241
182	void ChartAxis::setGridVisibility(bool visible)	242	void ChartAxis::axisSelected()
183	{	243	{
184	m_grid->setOpacity(visible);	244	emit clicked();
185	}	245	}
186		246
187	void ChartAxis::setLabelsOpacity(qreal opacity)	247	Qt::Orientation ChartAxis::orientation() const
188	{	248	{
189	m_labels->setOpacity(opacity);	249	return m_axis->orientation();
190	}	250	}
191		251
192	~~qreal~~ ChartAxis::label~~sOpac~~ity() const	252	Qt::Alignment ChartAxis::alignment() const
		253	{
		254	return m_axis->alignment();
		255	}
		256
		257	void ChartAxis::setLabels(const QStringList &labels)
		258	{
		259	m_labelsList = labels;
		260	}
		261
		262	QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
193	{	263	{
194	return m_labels->opacity();	264	Q_UNUSED(which);
		265	Q_UNUSED(constraint);
		266	return QSizeF();
195	}	267	}
196		268
197	void ChartAxis::setLabelsVisibility(bool visible)	269	//handlers
		270
		271	void ChartAxis::handleArrowVisibleChanged(bool visible)
198	{	272	{
199	m_~~labels~~->set~~Opacity~~(visible);	273	m_arrow->setVisible(visible);
200	}	274	}
201		275
202	void ChartAxis::setShadesOpacity(qreal opacity)	276	void ChartAxis::handleGridVisibleChanged(bool visible)
203	{	277	{
204	m_shades->setOpacity(opacity);	278	m_grid->setVisible(visible);
205	}	279	}
206		280
207	qreal ChartAxis::shadesOpacity() const	281	void ChartAxis::handleLabelsVisibleChanged(bool visible)
208	{	282	{
209	return m_shades->opacity();	283	m_labels->setVisible(visible);
210	}	284	}
211		285
212	void ChartAxis::~~set~~ShadesVisib~~ility~~(bool visible)	286	void ChartAxis::handleShadesVisibleChanged(bool visible)
213	{	287	{
214	m_shades->setVisible(visible);	288	m_shades->setVisible(visible);
215	}	289	}
216		290
217	void ChartAxis::~~set~~LabelsAngle(int angle)	291	void ChartAxis::handleLabelsAngleChanged(int angle)
218	{	292	{
219	foreach (QGraphicsItem *item, m_labels->childItems())	293	foreach (QGraphicsItem *item, m_labels->childItems())
220	item->setRotation(angle);	294	item->setRotation(angle);
@@ -222,145 +296,69 void ChartAxis::setLabelsAngle(int angle)
222	m_labelsAngle = angle;	296	m_labelsAngle = angle;
223	}	297	}
224		298
225	void ChartAxis::~~set~~LabelsPen(const QPen &pen)	299	void ChartAxis::handleLabelsPenChanged(const QPen &pen)
226	{	300	{
227	foreach (QGraphicsItem *item , m_labels->childItems())	301	foreach (QGraphicsItem *item , m_labels->childItems())
228	static_cast<QGraphicsSimpleTextItem *>(item)->setPen(pen);	302	static_cast<QGraphicsSimpleTextItem *>(item)->setPen(pen);
229	}	303	}
230		304
231	void ChartAxis::~~set~~LabelsBrush(const QBrush &brush)	305	void ChartAxis::handleLabelsBrushChanged(const QBrush &brush)
232	{	306	{
233	foreach (QGraphicsItem *item , m_labels->childItems())	307	foreach (QGraphicsItem *item , m_labels->childItems())
234	static_cast<QGraphicsSimpleTextItem *>(item)->setBrush(brush);	308	static_cast<QGraphicsSimpleTextItem *>(item)->setBrush(brush);
235	}	309	}
236		310
237	void ChartAxis::~~set~~LabelsFont(const QFont &font)	311	void ChartAxis::handleLabelsFontChanged(const QFont &font)
238	{	312	{
239	if (m_font != font) {	313	foreach (QGraphicsItem *item , m_labels->childItems())
240	m_font = font;	314	static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);
241	foreach (QGraphicsItem *item , m_labels->childItems())	315	QGraphicsLayoutItem::updateGeometry();
242	static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);	316	presenter()->layout()->invalidate();
243	QGraphicsLayoutItem::updateGeometry();
244	presenter()->layout()->invalidate();
245	}
246	}	317	}
247		318
248	void ChartAxis::~~set~~ShadesBrush(const QBrush &brush)	319	void ChartAxis::handleShadesBrushChanged(const QBrush &brush)
249	{	320	{
250	foreach (QGraphicsItem *item , m_shades->childItems())	321	foreach (QGraphicsItem *item , m_shades->childItems())
251	static_cast<QGraphicsRectItem *>(item)->setBrush(brush);	322	static_cast<QGraphicsRectItem *>(item)->setBrush(brush);
252	}	323	}
253		324
254	void ChartAxis::~~set~~ShadesPen(const QPen &pen)	325	void ChartAxis::handleShadesPenChanged(const QPen &pen)
255	{	326	{
256	foreach (QGraphicsItem *item , m_shades->childItems())	327	foreach (QGraphicsItem *item , m_shades->childItems())
257	static_cast<QGraphicsRectItem *>(item)->setPen(pen);	328	static_cast<QGraphicsRectItem *>(item)->setPen(pen);
258	}	329	}
259		330
260	void ChartAxis::~~set~~ArrowPen(const QPen &pen)	331	void ChartAxis::handleArrowPenChanged(const QPen &pen)
261	{	332	{
262	foreach (QGraphicsItem *item , m_arrow->childItems())	333	foreach (QGraphicsItem *item , m_arrow->childItems())
263	static_cast<QGraphicsLineItem *>(item)->setPen(pen);	334	static_cast<QGraphicsLineItem *>(item)->setPen(pen);
264	}	335	}
265		336
266	void ChartAxis::~~set~~GridPen(const QPen &pen)	337	void ChartAxis::handleGridPenChanged(const QPen &pen)
267	{	338	{
268	foreach (QGraphicsItem *item , m_grid->childItems())	339	foreach (QGraphicsItem *item , m_grid->childItems())
269	static_cast<QGraphicsLineItem *>(item)->setPen(pen);	340	static_cast<QGraphicsLineItem *>(item)->setPen(pen);
270	}	341	}
271		342
272	void ChartAxis::setLabelPadding(int padding)	343	void ChartAxis::handleTitleTextChanged(const QString &title)
273	{
274	m_labelPadding = padding;
275	}
276
277	bool ChartAxis::isEmpty()
278	{
279	return m_axisRect.isEmpty() \|\| m_gridRect.isEmpty() \|\| qFuzzyCompare(m_min, m_max);
280	}
281
282	void ChartAxis::handleDomainUpdated()
283	{	344	{
284	Domain domain = qobject_cast<Domain >(sender());	345	Q_UNUSED(title)
285	qreal min(0);	346	QGraphicsLayoutItem::updateGeometry();
286	qreal max(0);	347	presenter()->layout()->invalidate();
287
288	if (m_chartAxis->orientation() == Qt::Horizontal) {
289	min = domain->minX();
290	max = domain->maxX();
291	} else if (m_chartAxis->orientation() == Qt::Vertical) {
292	min = domain->minY();
293	max = domain->maxY();
294	}
295
296	if (!qFuzzyCompare(m_min, min) \|\| !qFuzzyCompare(m_max, max)) {
297	m_min = min;
298	m_max = max;
299
300	if (!isEmpty()) {
301
302	QVector<qreal> layout = calculateLayout();
303	updateLayout(layout);
304	QSizeF before = effectiveSizeHint(Qt::PreferredSize);
305	QSizeF after = sizeHint(Qt::PreferredSize);
306
307	if (before != after) {
308	QGraphicsLayoutItem::updateGeometry();
309	//we don't want to call invalidate on layout, since it will change minimum size of component,
310	//which we would like to avoid since it causes nasty flips when scrolling or zooming,
311	//instead recalculate layout and use plotArea for extra space.
312	presenter()->layout()->setGeometry(presenter()->layout()->geometry());
313	}
314	}
315	}
316	}	348	}
317		349
318	void ChartAxis::handleAxisUpdated()
319	{
320	if (isEmpty())
321	return;
322
323	bool visible = m_chartAxis->isVisible();
324
325	//TODO: split this into separate signal/slots ?
326	setArrowVisibility(visible && m_chartAxis->isLineVisible());
327	setGridVisibility(visible && m_chartAxis->isGridLineVisible());
328	setLabelsVisibility(visible && m_chartAxis->labelsVisible());
329	setShadesVisibility(visible && m_chartAxis->shadesVisible());
330	setLabelsAngle(m_chartAxis->labelsAngle());
331	setArrowPen(m_chartAxis->linePen());
332	setLabelsPen(m_chartAxis->labelsPen());
333	setLabelsBrush(m_chartAxis->labelsBrush());
334	setLabelsFont(m_chartAxis->labelsFont());
335	setGridPen(m_chartAxis->gridLinePen());
336	setShadesPen(m_chartAxis->shadesPen());
337	setShadesBrush(m_chartAxis->shadesBrush());
338	setTitleText(m_chartAxis->title());
339	setTitleFont(m_chartAxis->titleFont());
340	setTitlePen(m_chartAxis->titlePen());
341	setTitleBrush(m_chartAxis->titleBrush());
342	}
343
344	void ChartAxis::setTitleText(const QString &title)
345	{
346	if (m_titleText != title) {
347	m_titleText = title;
348	QGraphicsLayoutItem::updateGeometry();
349	presenter()->layout()->invalidate();
350	}
351	}
352		350
353	void ChartAxis::~~set~~TitlePen(const QPen &pen)	351	void ChartAxis::handleTitlePenChanged(const QPen &pen)
354	{	352	{
355	m_title->setPen(pen);	353	m_title->setPen(pen);
356	}	354	}
357		355
358	void ChartAxis::~~set~~TitleBrush(const QBrush &brush)	356	void ChartAxis::handleTitleBrushChanged(const QBrush &brush)
359	{	357	{
360	m_title->setBrush(brush);	358	m_title->setBrush(brush);
361	}	359	}
362		360
363	void ChartAxis::~~set~~TitleFont(const QFont &font)	361	void ChartAxis::handleTitleFontChanged(const QFont &font)
364	{	362	{
365	if(m_title->font() != font){	363	if(m_title->font() != font){
366	m_title->setFont(font);	364	m_title->setFont(font);
@@ -369,80 +367,59 void ChartAxis::setTitleFont(const QFont &font)
369	}	367	}
370	}	368	}
371		369
372	QFont ChartAxis::titleFont() const	370	void ChartAxis::handleVisibleChanged(bool visible)
373	{
374	return m_title->font();
375	}
376
377	void ChartAxis::hide()
378	{	371	{
379	setArrowVisibility(false);	372	setVisible(visible);
380	setGridVisibility(false);
381	setLabelsVisibility(false);
382	setShadesVisibility(false);
383	}	373	}
384		374
385	void ChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)	375	void ChartAxis::handleRangeChanged(qreal min, qreal max)
386	{	376	{
387	m_gridRect = grid;	377	Q_UNUSED(min);
388	m_axisRect = axis;	378	Q_UNUSED(max);
389
390	if (isEmpty())
391	return;
392
393	QVector<qreal> layout = calculateLayout();
394	updateLayout(layout);
395		379
396	}	380	if (!isEmpty()) {
397		381
398	void ChartAxis::axisSelected()	382	QVector<qreal> layout = calculateLayout();
399	{	383	updateLayout(layout);
400	//TODO: axis clicked;	384	QSizeF before = effectiveSizeHint(Qt::PreferredSize);
401	}	385	QSizeF after = sizeHint(Qt::PreferredSize);
402		386
403	Qt::Orientation ChartAxis::orientation() const	387	if (before != after) {
404	{	388	QGraphicsLayoutItem::updateGeometry();
405	return m_chartAxis->orientation();	389	//we don't want to call invalidate on layout, since it will change minimum size of component,
406	}	390	//which we would like to avoid since it causes nasty flips when scrolling or zooming,
		391	//instead recalculate layout and use plotArea for extra space.
		392	presenter()->layout()->setGeometry(presenter()->layout()->geometry());
		393	}
		394	}
407		395
408	Qt::Alignment ChartAxis::alignment() const
409	{
410	return m_chartAxis->alignment();
411	}
412
413	bool ChartAxis::isVisible()
414	{
415	return m_chartAxis->isVisible();
416	}	396	}
417		397
418	void ChartAxis::setLabels(const QStringList &labels)	398	//helpers
419	{
420	m_labelsList = labels;
421	}
422		399
423	QStringList ChartAxis::createValueLabels(int ticks) ~~const~~	400	QStringList ChartAxis::createValueLabels(qreal min, qreal max, int ticks,const QString& format)
424	{	401	{
425	Q_ASSERT(m_max > m_min);	402	//TODO: Q_ASSERT(m_max > m_min);
426	Q_ASSERT(ticks > 1);	403	//TODO: Q_ASSERT(ticks > 1);
427		404
428	QStringList labels;	405	QStringList labels;
429		406
430	int n = qMax(int(-qFloor(log10((m_max - m_min) / (ticks - 1)))), 0);	407	if(max <= min \|\| ticks < 1){
431	n++;	408	return labels;
432		409	}
433	QValueAxis axis = qobject_cast<QValueAxis >(m_chartAxis);
434		410
435	QString format = axis->labelFormat();	411	int n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
		412	n++;
436		413
437	if (format.isNull()) {	414	if (format.isNull()) {
438	for (int i = 0; i < ticks; i++) {	415	for (int i = 0; i < ticks; i++) {
439	qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));	416	qreal value = min + (i * (max - min) / (ticks - 1));
440	labels << QString::number(value, 'f', n);	417	labels << QString::number(value, 'f', n);
441	}	418	}
442	} else {	419	} else {
443	QByteArray array = format.toLatin1();	420	QByteArray array = format.toLatin1();
444	for (int i = 0; i < ticks; i++) {	421	for (int i = 0; i < ticks; i++) {
445	qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));	422	qreal value = min + (i * (max - min) / (ticks - 1));
446	if (format.contains("d")	423	if (format.contains("d")
447	\|\| format.contains("i")	424	\|\| format.contains("i")
448	\|\| format.contains("c"))	425	\|\| format.contains("c"))
@@ -461,27 +438,25 QStringList ChartAxis::createValueLabels(int ticks) const
461	return labels;	438	return labels;
462	}	439	}
463		440
464	QStringList ChartAxis::createDateTimeLabels(const QString &format, ~~int~~ ~~ticks~~) ~~const~~	441	QStringList ChartAxis::createDateTimeLabels(qreal min, qreal max,int ticks,const QString& format)
465	{	442	{
466	Q_ASSERT(m_max > m_min);	443	//TODO: Q_ASSERT(m_max > m_min);
467	Q_ASSERT(ticks > 1);	444	//TODO: Q_ASSERT(ticks > 1);
468	QStringList labels;	445	QStringList labels;
469	int n = qMax(int(-floor(log10((m_max - m_min) / (ticks - 1)))), 0);	446
		447	if(max <= min \|\| ticks < 1) {
		448	return labels;
		449	}
		450
		451	int n = qMax(int(-floor(log10((max - min) / (ticks - 1)))), 0);
470	n++;	452	n++;
471	for (int i = 0; i < ticks; i++) {	453	for (int i = 0; i < ticks; i++) {
472	qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));	454	qreal value = min + (i * (max - min) / (ticks - 1));
473	labels << QDateTime::fromMSecsSinceEpoch(value).toString(format);	455	labels << QDateTime::fromMSecsSinceEpoch(value).toString(format);
474	}	456	}
475	return labels;	457	return labels;
476	}	458	}
477		459
478	QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
479	{
480	Q_UNUSED(which);
481	Q_UNUSED(constraint);
482	return QSizeF();
483	}
484
485	#include "moc_chartaxis_p.cpp"	460	#include "moc_chartaxis_p.cpp"
486		461
487	QTCOMMERCIALCHART_END_NAMESPACE	462	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxis_p.h +48 -54

@@ -48,48 +48,16 class ChartAxis : public ChartElement, public QGraphicsLayoutItem
48	Q_INTERFACES(QGraphicsLayoutItem)	48	Q_INTERFACES(QGraphicsLayoutItem)
49	public:	49	public:
50		50
51	ChartAxis(QAbstractAxis axis, ~~ChartPresenter~~ ~~presenter~~, bool intervalAxis = false);	51	ChartAxis(QAbstractAxis axis, QGraphicsItem item = 0, bool intervalAxis = false);
52	~ChartAxis();	52	~ChartAxis();
53		53
54	QAbstractAxis* axis() const { return m_cha~~rtA~~xis; }	54	QAbstractAxis* axis() const { return m_axis; }
55		55
56	void setArrowOpacity(qreal opacity);
57	qreal arrowOpacity() const;
58	void setArrowVisibility(bool visible);
59
60	void setGridOpacity(qreal opacity);
61	qreal gridOpacity() const;
62	void setGridVisibility(bool visible);
63
64	void setLabelsOpacity(qreal opacity);
65	qreal labelsOpacity() const;
66	void setLabelsVisibility(bool visible);
67
68	void setShadesOpacity(qreal opacity);
69	qreal shadesOpacity() const;
70	void setShadesVisibility(bool visible);
71
72	void setLabelsAngle(int angle);
73	int labelsAngle()const { return m_labelsAngle; }
74
75	void setShadesBrush(const QBrush &brush);
76	void setShadesPen(const QPen &pen);
77
78	void setArrowPen(const QPen &pen);
79	void setGridPen(const QPen &pen);
80
81	void setLabelsPen(const QPen &pen);
82	void setLabelsBrush(const QBrush &brush);
83	void setLabelsFont(const QFont &font);
84	void setLabelPadding(int padding);	56	void setLabelPadding(int padding);
85	int labelPadding() const { return m_labelPadding;};	57	int labelPadding() const { return m_labelPadding;};
86		58
87	void setTitlePen(const QPen &pen);
88	void setTitleBrush(const QBrush &brush);
89	void setTitleFont(const QFont &font);
90	QFont titleFont() const;	59	QFont titleFont() const;
91	void setTitleText(const QString &title);	60	QString titleText() const;
92	QString titleText() const {return m_titleText; };
93		61
94	void setLayout(QVector<qreal> &layout);	62	void setLayout(QVector<qreal> &layout);
95	QVector<qreal> layout() const { return m_layoutVector; }	63	QVector<qreal> layout() const { return m_layoutVector; }
@@ -100,9 +68,6 public:
100	Qt::Orientation orientation() const;	68	Qt::Orientation orientation() const;
101	Qt::Alignment alignment() const;	69	Qt::Alignment alignment() const;
102		70
103	bool isVisible();
104	void hide();
105
106	void setGeometry(const QRectF &axis, const QRectF &grid);	71	void setGeometry(const QRectF &axis, const QRectF &grid);
107	QRectF axisGeometry() const { return m_axisRect; }	72	QRectF axisGeometry() const { return m_axisRect; }
108	QRectF gridGeometry() const { return m_gridRect; }	73	QRectF gridGeometry() const { return m_gridRect; }
@@ -115,6 +80,20 public:
115		80
116	virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;	81	virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
117		82
		83
		84	QRectF boundingRect() const{
		85	return QRectF();
		86	}
		87
		88	void paint(QPainter, const QStyleOptionGraphicsItem, QWidget*)
		89	{
		90
		91	}
		92
		93	//helpers
		94	static QStringList createValueLabels(qreal max, qreal min, int ticks, const QString &format);
		95	static QStringList createDateTimeLabels(qreal max, qreal min, int ticks, const QString &format);
		96
118	protected:	97	protected:
119	void setGeometry(const QRectF &size) { Q_UNUSED(size);};	98	void setGeometry(const QRectF &size) { Q_UNUSED(size);};
120	virtual void updateGeometry() = 0;	99	virtual void updateGeometry() = 0;
@@ -126,15 +105,33 protected:
126	QList<QGraphicsItem *> arrowItems() { return m_arrow->childItems();};	105	QList<QGraphicsItem *> arrowItems() { return m_arrow->childItems();};
127	QGraphicsSimpleTextItem* titleItem() const { return m_title.data();}	106	QGraphicsSimpleTextItem* titleItem() const { return m_title.data();}
128		107
129	QFont font() const { ~~return~~ ~~m_font~~; }	108	QFont font() const;
130	qreal min() const {~~return~~ ~~m_min~~; }	109	qreal min() const;
131	qreal max() const {~~return~~ ~~m_max~~; }	110	qreal max() const;
132	QStringList createValueLabels(int ticks) const;
133	QStringList createDateTimeLabels(const QString &format, int ticks) const;
134		111
		112	//handlers
135	public Q_SLOTS:	113	public Q_SLOTS:
136	virtual void handleAxisUpdated();	114	void handleVisibleChanged(bool visible);
137	virtual void handleDomainUpdated();	115	void handleArrowVisibleChanged(bool visible);
		116	void handleGridVisibleChanged(bool visible);
		117	void handleLabelsVisibleChanged(bool visible);
		118	void handleShadesVisibleChanged(bool visible);
		119	void handleLabelsAngleChanged(int angle);
		120	void handleShadesBrushChanged(const QBrush &brush);
		121	void handleShadesPenChanged(const QPen &pen);
		122	void handleArrowPenChanged(const QPen &pen);
		123	void handleGridPenChanged(const QPen &pen);
		124	void handleLabelsPenChanged(const QPen &pen);
		125	void handleLabelsBrushChanged(const QBrush &brush);
		126	void handleLabelsFontChanged(const QFont &font);
		127	void handleTitlePenChanged(const QPen &pen);
		128	void handleTitleBrushChanged(const QBrush &brush);
		129	void handleTitleFontChanged(const QFont &font);
		130	void handleTitleTextChanged(const QString &title);
		131	void handleRangeChanged(qreal min , qreal max);
		132
		133	Q_SIGNALS:
		134	void clicked();
138		135
139	private:	136	private:
140	inline bool isEmpty();	137	inline bool isEmpty();
@@ -142,37 +139,34 private:
142	void deleteItems(int count);	139	void deleteItems(int count);
143	void updateLayout(QVector<qreal> &layout);	140	void updateLayout(QVector<qreal> &layout);
144	void axisSelected();	141	void axisSelected();
		142	void connectSlots();
145		143
146	private:	144	private:
147	QAbstractAxis *m_cha~~rtA~~xis;	145	QAbstractAxis *m_axis;
148	int m_labelsAngle;	146	int m_labelsAngle;
149	QRectF m_axisRect;	147	QRectF m_axisRect;
150	QRectF m_gridRect;	148	QRectF m_gridRect;
151	QScopedPointer<QGraphicsItemGroup> m_grid;	149	QScopedPointer<QGraphicsItemGroup> m_grid;
		150	QScopedPointer<QGraphicsItemGroup> m_arrow;
152	QScopedPointer<QGraphicsItemGroup> m_shades;	151	QScopedPointer<QGraphicsItemGroup> m_shades;
153	QScopedPointer<QGraphicsItemGroup> m_labels;	152	QScopedPointer<QGraphicsItemGroup> m_labels;
154	QScopedPointer<QGraphicsItemGroup> m_arrow;
155	QScopedPointer<QGraphicsSimpleTextItem> m_title;	153	QScopedPointer<QGraphicsSimpleTextItem> m_title;
156	QVector<qreal> m_layoutVector;	154	QVector<qreal> m_layoutVector;
157	qreal m_min;
158	qreal m_max;
159	AxisAnimation *m_animation;	155	AxisAnimation *m_animation;
160	QFont m_font;
161	QString m_titleText;
162	int m_labelPadding;	156	int m_labelPadding;
163	QStringList m_labelsList;	157	QStringList m_labelsList;
164	bool m_intervalAxis;	158	bool m_intervalAxis;
165		159
166	friend class AxisAnimation;	160	friend class AxisAnimation;
167	friend class A~~xis~~Item;	161	friend class ArrowItem;
168		162
169	};	163	};
170		164
171	class A~~xis~~Item: public QGraphicsLineItem	165	class ArrowItem: public QGraphicsLineItem
172	{	166	{
173		167
174	public:	168	public:
175	explicit A~~xis~~Item(ChartAxis axis, QGraphicsItem parent = 0) : QGraphicsLineItem(parent), m_axis(axis) {}	169	explicit ArrowItem(ChartAxis axis, QGraphicsItem parent = 0) : QGraphicsLineItem(parent), m_axis(axis) {}
176		170
177	protected:	171	protected:
178	void mousePressEvent(QGraphicsSceneMouseEvent *event) {	172	void mousePressEvent(QGraphicsSceneMouseEvent *event) {

src/axis/datetimeaxis/chartdatetimeaxisx.cpp +20 -15

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartDateTimeAxisX::ChartDateTimeAxisX(QDateTimeAxis *axis, ChartPresenter *presenter)
+            ChartDateTimeAxisX::ChartDateTimeAxisX(QDateTimeAxis *axis, QGraphicsItem* item)
-                : HorizontalAxis(axis, presenter),
+                : HorizontalAxis(axis, item),
-                  m_tickCount(0),
                   m_axis(axis)
             {
+                QObject::connect(m_axis,SIGNAL(tickCountChanged(int)),this, SLOT(handleTickCountChanged(int)));
             }
             ChartDateTimeAxisX::~ChartDateTimeAxisX()
             QVector<qreal> ChartDateTimeAxisX::calculateLayout() const
             {
-                Q_ASSERT(m_tickCount >= 2);
+                int tickCount = m_axis->tickCount();
+                Q_ASSERT(tickCount >= 2);
                 QVector<qreal> points;
-                points.resize(m_tickCount);
+                points.resize(tickCount);
                 const QRectF &gridRect = gridGeometry();
-                const qreal deltaX = gridRect.width() / (m_tickCount - 1);
+                const qreal deltaX = gridRect.width() / (tickCount - 1);
-                for (int i = 0; i < m_tickCount; ++i) {
+                for (int i = 0; i < tickCount; ++i) {
                     int x = i * deltaX + gridRect.left();
                     points[i] = x;
                 }
                 const QVector<qreal>& layout = ChartAxis::layout();
                 if (layout.isEmpty())
                     return;
-                setLabels(createDateTimeLabels(m_axis->format(), layout.size()));
+                setLabels(createDateTimeLabels(min(),max(), layout.size(),m_axis->format()));
                 HorizontalAxis::updateGeometry();
             }
-            void ChartDateTimeAxisX::handleAxisUpdated()
+            void ChartDateTimeAxisX::handleTickCountChanged(int tick)
             {
-                if (m_tickCount != m_axis->tickCount()) {
+                Q_UNUSED(tick)
-                    m_tickCount = m_axis->tickCount();
+                if(presenter()) presenter()->layout()->invalidate();
-                    presenter()->layout()->invalidate();
-                ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartDateTimeAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
-                QStringList ticksList = createDateTimeLabels(m_axis->format(), m_tickCount);
+                QStringList ticksList = createDateTimeLabels(min(),max(),m_axis->tickCount(),m_axis->format());
                 qreal width = 0;
                 qreal height = 0;
+                if(ticksList.empty()){
+                    return sh;
+                }
                 switch (which) {
                 case Qt::MinimumSize:{
                 return sh;
             }
+            #include "moc_chartdatetimeaxisx_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/datetimeaxis/chartdatetimeaxisx_p.h +4 -3

             class ChartDateTimeAxisX : public HorizontalAxis
             {
+                Q_OBJECT
             public:
-                ChartDateTimeAxisX(QDateTimeAxis *axis, ChartPresenter *presenter);
+                ChartDateTimeAxisX(QDateTimeAxis *axis, QGraphicsItem* item = 0);
                 ~ChartDateTimeAxisX();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
-                void handleAxisUpdated();
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();
+            private Q_SLOTS:
+                void handleTickCountChanged(int tick);
             private:
-                int m_tickCount;
                 QDateTimeAxis *m_axis;
             };

src/axis/datetimeaxis/chartdatetimeaxisy.cpp +20 -15

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartDateTimeAxisY::ChartDateTimeAxisY(QDateTimeAxis *axis, ChartPresenter *presenter)
+            ChartDateTimeAxisY::ChartDateTimeAxisY(QDateTimeAxis *axis, QGraphicsItem* item)
-                : VerticalAxis(axis, presenter),
+                : VerticalAxis(axis, item),
-                  m_tickCount(0),
                   m_axis(axis)
             {
+                QObject::connect(m_axis,SIGNAL(tickCountChanged(int)),this, SLOT(handleTickCountChanged(int)));
             }
             ChartDateTimeAxisY::~ChartDateTimeAxisY()
             QVector<qreal> ChartDateTimeAxisY::calculateLayout() const
             {
-                Q_ASSERT(m_tickCount >= 2);
+                int tickCount = m_axis->tickCount();
+                Q_ASSERT(tickCount >= 2);
                 QVector<qreal> points;
-                points.resize(m_tickCount);
+                points.resize(tickCount);
                 const QRectF &gridRect = gridGeometry();
-                const qreal deltaY = gridRect.height() / (m_tickCount - 1);
+                const qreal deltaY = gridRect.height() / (tickCount - 1);
-                for (int i = 0; i < m_tickCount; ++i) {
+                for (int i = 0; i < tickCount; ++i) {
                     int y = i * -deltaY + gridRect.bottom();
                     points[i] = y;
                 }
                 const QVector<qreal> &layout = ChartAxis::layout();
                 if (layout.isEmpty())
                     return;
-                setLabels(createDateTimeLabels(m_axis->format(), layout.size()));
+                setLabels(createDateTimeLabels(min(),max(), layout.size(),m_axis->format()));
                 VerticalAxis::updateGeometry();
             }
-            void ChartDateTimeAxisY::handleAxisUpdated()
+            void ChartDateTimeAxisY::handleTickCountChanged(int tick)
             {
-                if (m_tickCount != m_axis->tickCount()) {
+                Q_UNUSED(tick)
-                    m_tickCount = m_axis->tickCount();
+                if(presenter()) presenter()->layout()->invalidate();
-                    presenter()->layout()->invalidate();
-                ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartDateTimeAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
-                QStringList ticksList = createDateTimeLabels(m_axis->format(),m_tickCount);
+                QStringList ticksList = createDateTimeLabels(min(),max(),m_axis->tickCount(),m_axis->format());
                 qreal width = 0;
                 qreal height = 0;
+                if(ticksList.empty()){
+                    return sh;
+                }
                 switch (which) {
                     case Qt::MinimumSize: {
                         width = fn.boundingRect("...").width() + labelPadding();
                 return sh;
             }
+            #include "moc_chartdatetimeaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/datetimeaxis/chartdatetimeaxisy_p.h +4 -3

             class ChartDateTimeAxisY : public VerticalAxis
             {
+                Q_OBJECT
             public:
-                ChartDateTimeAxisY(QDateTimeAxis *axis, ChartPresenter *presenter);
+                ChartDateTimeAxisY(QDateTimeAxis *axis, QGraphicsItem* item = 0);
                 ~ChartDateTimeAxisY();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();
-                void handleAxisUpdated();
+            private Q_SLOTS:
+                void handleTickCountChanged(int tick);
             private:
-                int m_tickCount;
                 QDateTimeAxis *m_axis;
             };

src/axis/datetimeaxis/qdatetimeaxis.cpp +47 -44

             #include "chartdatetimeaxisx_p.h"
             #include "chartdatetimeaxisy_p.h"
             #include "domain_p.h"
+            #include "qchart.h"
             #include <float.h>
             #include <cmath>
             */
             QDateTimeAxis::~QDateTimeAxis()
             {
+                Q_D(QDateTimeAxis);
+                if (d->m_chart)
+                    d->m_chart->removeAxis(this);
             }
             void QDateTimeAxis::setMin(QDateTime min)
             {
                 Q_D(QDateTimeAxis);
                 if (min.isValid())
-                    setRange(min, qMax(d->m_max, min));
+                    d->setRange(min.toMSecsSinceEpoch(), qMax(d->m_max, qreal(min.toMSecsSinceEpoch())));
             }
             QDateTime QDateTimeAxis::min() const
             {
                 Q_D(const QDateTimeAxis);
-                return d->m_min;
+                return QDateTime::fromMSecsSinceEpoch(d->m_min);
             }
             void QDateTimeAxis::setMax(QDateTime max)
             {
                 Q_D(QDateTimeAxis);
                 if (max.isValid())
-                    setRange(qMin(d->m_min, max), max);
+                    d->setRange(qMin(d->m_min, qreal(max.toMSecsSinceEpoch())), max.toMSecsSinceEpoch());
             }
             QDateTime QDateTimeAxis::max() const
             {
                 Q_D(const QDateTimeAxis);
-                return d->m_max;
+                return QDateTime::fromMSecsSinceEpoch(d->m_max);
             }
             /*!
                 if (!min.isValid() || !max.isValid() || min > max)
                     return;
-                bool changed = false;
+                d->setRange(min.toMSecsSinceEpoch(),max.toMSecsSinceEpoch());
-                if (d->m_min != min) {
-                    d->m_min = min;
-                    changed = true;
-                    emit minChanged(min);
-                if (d->m_max != max) {
-                    d->m_max = max;
-                    changed = true;
-                    emit maxChanged(max);
-                if (changed) {
-                    emit rangeChanged(d->m_min, d->m_max);
-                    d->emitUpdated();
             }
             void QDateTimeAxis::setFormat(QString format)
                 Q_D(QDateTimeAxis);
                 if (d->m_tickCount != count && count >= 2) {
                     d->m_tickCount = count;
-                    d->emitUpdated();
+                   emit tickCountChanged(count);
                 }
             }
             QDateTimeAxisPrivate::QDateTimeAxisPrivate(QDateTimeAxis *q)
                 : QAbstractAxisPrivate(q),
-                  m_min(QDateTime::fromMSecsSinceEpoch(0)),
+                  m_min(0),
-                  m_max(QDateTime::fromMSecsSinceEpoch(0)),
+                  m_max(0),
                   m_tickCount(5)
             {
                 m_format = "dd-MM-yyyy\nh:mm";
             }
-            void QDateTimeAxisPrivate::handleDomainUpdated()
+            void QDateTimeAxisPrivate::setRange(qreal min,qreal max)
             {
                 Q_Q(QDateTimeAxis);
-                Domain *domain = qobject_cast<Domain *>(sender());
-                Q_ASSERT(domain);
-                if (orientation() == Qt::Horizontal)
+                bool changed = false;
-                    q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minX()), QDateTime::fromMSecsSinceEpoch(domain->maxX()));
-                else if (orientation() == Qt::Vertical)
+                if (m_min != min) {
-                    q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minY()), QDateTime::fromMSecsSinceEpoch(domain->maxY()));
+                    m_min = min;
+                    changed = true;
+                    emit q->minChanged(QDateTime::fromMSecsSinceEpoch(min));
+                }
+                if (m_max != max) {
+                    m_max = max;
+                    changed = true;
+                    emit q->maxChanged(QDateTime::fromMSecsSinceEpoch(max));
+                }
+                if (changed) {
+                    emit q->rangeChanged(QDateTime::fromMSecsSinceEpoch(min), QDateTime::fromMSecsSinceEpoch(max));
+                    emit rangeChanged(m_min,m_max);
+                }
             }
                     q->setRange(min.toDateTime(), max.toDateTime());
             }
-            ChartAxis *QDateTimeAxisPrivate::createGraphics(ChartPresenter *presenter)
+            void QDateTimeAxisPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QDateTimeAxis);
-                if (m_orientation == Qt::Vertical)
+                ChartAxis* axis(0);
-                    return new ChartDateTimeAxisY(q, presenter);
+                if (orientation() == Qt::Vertical)
-                return new ChartDateTimeAxisX(q, presenter);
+                    axis = new ChartDateTimeAxisY(q,parent);
+                if (orientation() == Qt::Horizontal)
+                    axis = new ChartDateTimeAxisX(q,parent);
+                m_item.reset(axis);
+                QAbstractAxisPrivate::initializeGraphics(parent);
             }
-            void QDateTimeAxisPrivate::intializeDomain(Domain *domain)
+            void QDateTimeAxisPrivate::initializeDomain(Domain *domain)
             {
-                Q_Q(QDateTimeAxis);
                 if (m_max == m_min) {
-                    if (m_orientation == Qt::Vertical)
+                    if (orientation() == Qt::Vertical)
-                        q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minY()), QDateTime::fromMSecsSinceEpoch(domain->maxY()));
+                        setRange(domain->minY(), domain->maxY());
                     else
-                        q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minX()), QDateTime::fromMSecsSinceEpoch(domain->maxX()));
+                        setRange(domain->minX(), domain->maxX());
                 } else {
-                    if (m_orientation == Qt::Vertical)
+                    if (orientation() == Qt::Vertical)
-                        domain->setRangeY(m_min.toMSecsSinceEpoch(), m_max.toMSecsSinceEpoch());
+                        domain->setRangeY(m_min, m_max);
                     else
-                        domain->setRangeX(m_min.toMSecsSinceEpoch(), m_max.toMSecsSinceEpoch());
+                        domain->setRangeX(m_min, m_max);
                 }
             }

src/axis/datetimeaxis/qdatetimeaxis.h +2 -1

             class QTCOMMERCIALCHART_EXPORT QDateTimeAxis : public QAbstractAxis
             {
                 Q_OBJECT
-                Q_PROPERTY(int tickCount READ tickCount WRITE setTickCount)
+                Q_PROPERTY(int tickCount READ tickCount WRITE setTickCount NOTIFY tickCountChanged)
                 Q_PROPERTY(QDateTime min READ min WRITE setMin NOTIFY minChanged)
                 Q_PROPERTY(QDateTime max READ max WRITE setMax NOTIFY maxChanged)
                 Q_PROPERTY(QString format READ format WRITE setFormat NOTIFY formatChanged)
                 void maxChanged(QDateTime max);
                 void rangeChanged(QDateTime min, QDateTime max);
                 void formatChanged(QString format);
+                void tickCountChanged(int tick);
             private:
                 Q_DECLARE_PRIVATE(QDateTimeAxis)

src/axis/datetimeaxis/qdatetimeaxis_p.h +12 -9

                 ~QDateTimeAxisPrivate();
             public:
-                ChartAxis *createGraphics(ChartPresenter *presenter);
+                void initializeGraphics(QGraphicsItem* parent);
-                void intializeDomain(Domain *domain);
+                void initializeDomain(Domain *domain);
-                void handleDomainUpdated();
-                qreal min() { return m_min.toMSecsSinceEpoch(); }
-                qreal max() { return m_max.toMSecsSinceEpoch(); }
-                int count() const { /*TODO:*/ return 0;}
-            protected:
+                //interface for manipulating range form base class
                 void setMin(const QVariant &min);
                 void setMax(const QVariant &max);
                 void setRange(const QVariant &min, const QVariant &max);
+                //interface manipulating range form domain
+                qreal min() { return m_min; }
+                qreal max() { return m_max; }
+                void setRange(qreal min,qreal max);
+            protected:
                 int tickCount() const;
             protected:
-                QDateTime m_min;
+                qreal m_min;
-                QDateTime m_max;
+                qreal m_max;
                 int m_tickCount;
                 QString m_format;
                 Q_DECLARE_PUBLIC(QDateTimeAxis)

src/axis/horizontalaxis.cpp +3 -3

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            HorizontalAxis::HorizontalAxis(QAbstractAxis *axis, ChartPresenter *presenter, bool intervalAxis)
+            HorizontalAxis::HorizontalAxis(QAbstractAxis *axis, QGraphicsItem* item , bool intervalAxis)
-                : ChartAxis(axis, presenter, intervalAxis)
+                : ChartAxis(axis, item, intervalAxis)
             {
             }
                     break;
                 case Qt::MaximumSize:
                 case Qt::PreferredSize:
-                        sh = QSizeF(fn.boundingRect(axis()->title()).width(), fn.height());
+                        sh = QSizeF(fn.boundingRect(axis()->titleText()).width(), fn.height());
                     break;
                 default:
                     break;

src/axis/horizontalaxis_p.h +1 -1

             class HorizontalAxis : public ChartAxis
             {
             public:
-                HorizontalAxis(QAbstractAxis *axis, ChartPresenter *presenter, 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/qabstractaxis.cpp +121 -49

             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
+            #include "chartdataset_p.h"
+            #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QAbstractAxis::~QAbstractAxis()
             {
-                if (d_ptr->m_dataset)
+                if (d_ptr->m_chart)
                     qFatal("Still binded axis detected !");
             }
             {
                 if (d_ptr->m_axisPen != pen) {
                     d_ptr->m_axisPen = pen;
-                    d_ptr->emitUpdated();
+                    emit linePenChanged(pen);
                 }
             }
                 return d_ptr->m_axisPen;
             }
+            //TODO: remove me
             void QAbstractAxis::setLinePenColor(QColor color)
             {
                 QPen p = d_ptr->m_axisPen;
             {
                 if (d_ptr->m_arrowVisible != visible) {
                     d_ptr->m_arrowVisible = visible;
-                    d_ptr->emitUpdated();
                     emit lineVisibleChanged(visible);
                 }
             }
             {
                 if (d_ptr->m_gridLineVisible != visible) {
                     d_ptr->m_gridLineVisible = visible;
-                    d_ptr->emitUpdated();
+                    emit gridLineVisibleChanged(visible);
-                    emit gridVisibleChanged(visible);
                 }
             }
             {
                 if (d_ptr->m_gridLinePen != pen) {
                     d_ptr->m_gridLinePen = pen;
-                    d_ptr->emitUpdated();
+                    emit gridLinePenChanged(pen);
                 }
             }
             {
                 if (d_ptr->m_labelsVisible != visible) {
                     d_ptr->m_labelsVisible = visible;
-                    d_ptr->emitUpdated();
                     emit labelsVisibleChanged(visible);
                 }
             }
             {
                 if (d_ptr->m_labelsPen != pen) {
                     d_ptr->m_labelsPen = pen;
-                    d_ptr->emitUpdated();
+                    emit labelsPenChanged(pen);
                 }
             }
             {
                 if (d_ptr->m_labelsBrush != brush) {
                     d_ptr->m_labelsBrush = brush;
-                    d_ptr->emitUpdated();
+                    emit labelsBrushChanged(brush);
                 }
             }
             {
                 if (d_ptr->m_labelsFont != font) {
                     d_ptr->m_labelsFont = font;
-                    d_ptr->emitUpdated();
+                    emit labelsFontChanged(font);
                 }
             }
             {
                 if (d_ptr->m_labelsAngle != angle) {
                     d_ptr->m_labelsAngle = angle;
-                    d_ptr->emitUpdated();
+                    emit labelsAngleChanged(angle);
                 }
             }
             {
                 return d_ptr->m_labelsAngle;
             }
+            //TODO: remove me
             void QAbstractAxis::setLabelsColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelsBrush;
             {
                 if (d_ptr->m_titleVisible != visible) {
                     d_ptr->m_titleVisible = visible;
-                    d_ptr->emitUpdated();
+                    emit labelsVisibleChanged(visible);
                 }
             }
             {
                 if (d_ptr->m_titlePen != pen) {
                     d_ptr->m_titlePen = pen;
-                    d_ptr->emitUpdated();
+                    emit titlePenChanged(pen);
                 }
             }
             {
                 if (d_ptr->m_titleBrush != brush) {
                     d_ptr->m_titleBrush = brush;
-                    d_ptr->emitUpdated();
+                    emit titleBrushChanged(brush);
                 }
             }
             {
                 if (d_ptr->m_titleFont != font) {
                     d_ptr->m_titleFont = font;
-                    d_ptr->emitUpdated();
+                    emit titleFontChanged(font);
                 }
             }
                 return d_ptr->m_titleFont;
             }
-            void QAbstractAxis::setTitle(const QString &title)
+            void QAbstractAxis::setTitleText(const QString &title)
             {
                 if (d_ptr->m_title != title) {
                     d_ptr->m_title = title;
-                    d_ptr->emitUpdated();
+                    emit titleTextChanged(title);
                 }
             }
-            QString QAbstractAxis::title() const
+            QString QAbstractAxis::titleText() const
             {
                 return d_ptr->m_title;
             }
             {
                 if (d_ptr->m_shadesVisible != visible) {
                     d_ptr->m_shadesVisible = visible;
-                    d_ptr->emitUpdated();
                     emit shadesVisibleChanged(visible);
                 }
             }
             {
                 if (d_ptr->m_shadesPen != pen) {
                     d_ptr->m_shadesPen = pen;
-                    d_ptr->emitUpdated();
+                    emit shadesPenChanged(pen);
                 }
             }
             {
                 if (d_ptr->m_shadesBrush != brush) {
                     d_ptr->m_shadesBrush = brush;
-                    d_ptr->emitUpdated();
+                    emit shadesBrushChanged(brush);
-                    emit shadesColorChanged(brush.color());
                 }
             }
             void QAbstractAxis::setShadesColor(QColor color)
             {
                 QBrush b = d_ptr->m_shadesBrush;
-                b.setColor(color);
+                if (b.color() != color) {
-                setShadesBrush(b);
+                    b.setColor(color);
+                    setShadesBrush(b);
+                    emit shadesColorChanged(color);
+                }
             }
             QColor QAbstractAxis::shadesColor() const
             void QAbstractAxis::setShadesBorderColor(QColor color)
             {
-                QPen p = d_ptr->m_shadesPen;
+            	QPen p = d_ptr->m_shadesPen;
-                p.setColor(color);
+            	if (p.color() != color) {
-                setShadesPen(p);
+            		p.setColor(color);
+            		setShadesPen(p);
+            		emit shadesColorChanged(color);
+            	}
             }
             QColor QAbstractAxis::shadesBorderColor() const
             {
                 if (d_ptr->m_visible != visible) {
                     d_ptr->m_visible = visible;
-                    d_ptr->emitUpdated();
                     emit visibleChanged(visible);
                 }
             }
             // http://techbase.kde.org/Policies/Binary_Compatibility_Examples#Change_the_CV-qualifiers_of_a_member_function
             Qt::Orientation QAbstractAxis::orientation()
             {
-                return d_ptr->m_orientation;
+                return d_ptr->orientation();
             }
             Qt::Alignment QAbstractAxis::alignment() const
             {
-                return d_ptr->m_alignment;
+                return d_ptr->alignment();
-            void QAbstractAxis::setAlignment(Qt::Alignment alignment)
-                d_ptr->m_alignment = alignment;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis *q)
                 : q_ptr(q),
+                  m_chart(0),
                   m_orientation(Qt::Orientation(0)),
                   m_alignment(0),
-                  m_dataset(0),
                   m_visible(true),
                   m_arrowVisible(true),
                   m_gridLineVisible(true),
             QAbstractAxisPrivate::~QAbstractAxisPrivate()
             {
+            }
+            void QAbstractAxisPrivate::setAlignment( Qt::Alignment alignment)
+            {
+                switch(alignment) {
+                    case Qt::AlignTop:
+                    case Qt::AlignBottom:
+                    m_orientation = Qt::Horizontal;
+                    break;
+                    case Qt::AlignLeft:
+                    case Qt::AlignRight:
+                    m_orientation = Qt::Vertical;
+                    break;
+                    default:
+                    qWarning()<<"No alignment specified !";
+                    break;
+                };
+                m_alignment=alignment;
             }
-            void QAbstractAxisPrivate::emitUpdated()
+            void QAbstractAxisPrivate::initializeTheme(ChartTheme* theme, bool forced)
             {
-                if (!m_dirty) {
+                QPen pen;
-                    m_dirty = true;
+                QBrush brush;
-                    emit updated();
+                QFont font;
+                bool axisX = m_orientation == Qt::Horizontal;
+                if (m_arrowVisible) {
+                    if (forced || brush == m_labelsBrush){
+                        q_ptr->setLabelsBrush(theme->labelBrush());
+                    }
+                    //TODO: introduce axis brush
+                    if (forced || brush == m_titleBrush){
+                        q_ptr->setTitleBrush(theme->labelBrush());
+                    }
+                    if (forced || pen == m_labelsPen){
+                        q_ptr->setLabelsPen(Qt::NoPen);// NoPen for performance reasons
+                    }
+                    if (forced || pen == m_titlePen){
+                        q_ptr->setTitlePen(Qt::NoPen);// Noen for performance reasons
+                    }
+                    if (forced || m_shadesVisible) {
+                        if (forced || brush == m_shadesBrush){
+                            q_ptr->setShadesBrush(theme->backgroundShadesBrush());
+                        }
+                        if (forced || pen == m_shadesPen){
+                            q_ptr->setShadesPen(theme->backgroundShadesPen());
+                        }
+                        if (forced && (theme->backgroundShades() == ChartTheme::BackgroundShadesBoth
+                                || (theme->backgroundShades() == ChartTheme::BackgroundShadesVertical && axisX)
+                                || (theme->backgroundShades() == ChartTheme::BackgroundShadesHorizontal && !axisX))) {
+                        	 q_ptr->setShadesVisible(true);
+                        }
+                    }
+            		if (forced || pen == m_axisPen) {
+            			q_ptr->setLinePen(theme->axisLinePen());
+            		}
+            		if (forced || pen == m_gridLinePen) {
+            			q_ptr->setGridLinePen(theme->girdLinePen());
+            		}
+                    if (forced || font == m_labelsFont){
+                    	q_ptr->setLabelsFont(theme->labelFont());
+                    }
+                    //TODO: discuss with Tero
+                    if (forced || font == m_titleFont){
+                        QFont font(m_labelsFont);
+                        font.setBold(true);
+                        q_ptr->setTitleFont(font);
+                    }
                 }
             }
-            void QAbstractAxisPrivate::setDirty(bool dirty)
+            void QAbstractAxisPrivate::handleRangeChanged(qreal min, qreal max)
+            {
+                setRange(min,max);
+            }
+            void QAbstractAxisPrivate::initializeGraphics(QGraphicsItem* parent)
             {
-                m_dirty = dirty;
+                Q_UNUSED(parent);
             }
-            void QAbstractAxisPrivate::setOrientation(Qt::Orientation orientation)
+            void QAbstractAxisPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
-                m_orientation = orientation;
+                ChartAxis* axis = m_item.data();
-                if (m_orientation == Qt::Horizontal && !m_alignment)
+                Q_ASSERT(axis);
-                    m_alignment = Qt::AlignBottom;
+                if(options.testFlag(QChart::GridAxisAnimations)) {
-                else if (m_orientation == Qt::Vertical && !m_alignment)
+                    axis->setAnimation(new AxisAnimation(axis));
-                    m_alignment = Qt::AlignLeft;
+                }else{
+                    axis->setAnimation(0);
+                }
             }

src/axis/qabstractaxis.h +45 -17

             class QTCOMMERCIALCHART_EXPORT QAbstractAxis : public QObject
             {
                 Q_OBJECT
+                //visibility
                 Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged)
+                //arrow
                 Q_PROPERTY(bool lineVisible READ isLineVisible WRITE setLineVisible NOTIFY lineVisibleChanged)
+                Q_PROPERTY(QPen linePen READ linePen WRITE setLinePen NOTIFY linePenChanged)
+                //TODO: make wrapping of color for qml
                 Q_PROPERTY(QColor color READ linePenColor WRITE setLinePenColor NOTIFY colorChanged)
+                //labels
                 Q_PROPERTY(bool labelsVisible READ labelsVisible WRITE setLabelsVisible NOTIFY labelsVisibleChanged)
-                Q_PROPERTY(int labelsAngle READ labelsAngle WRITE setLabelsAngle)
+                Q_PROPERTY(QPen lablesPen READ labelsPen WRITE setLabelsPen NOTIFY labelsPenChanged)
-                Q_PROPERTY(QFont labelsFont READ labelsFont WRITE setLabelsFont)
+                Q_PROPERTY(QBrush lablesBrush READ labelsBrush WRITE setLabelsBrush NOTIFY labelsBrushChanged)
+                //TODO: fix labels angles to work with layout
+                Q_PROPERTY(int labelsAngle READ labelsAngle WRITE setLabelsAngle NOTIFY labelsAngleChanged)
+                Q_PROPERTY(QFont labelsFont READ labelsFont WRITE setLabelsFont NOTIFY labelsFontChanged)
+                //TODO: make wrapping of color for qml
                 Q_PROPERTY(QColor labelsColor READ labelsColor WRITE setLabelsColor NOTIFY labelsColorChanged)
-                Q_PROPERTY(bool gridVisible READ isGridLineVisible WRITE setGridLineVisible NOTIFY gridVisibleChanged)
+                //grid
+                Q_PROPERTY(bool gridVisible READ isGridLineVisible WRITE setGridLineVisible NOTIFY gridLineVisibleChanged)
+                Q_PROPERTY(QPen girdLinePen READ gridLinePen WRITE setGridLinePen NOTIFY gridLinePenChanged)
+                //shades
                 Q_PROPERTY(bool shadesVisible READ shadesVisible WRITE setShadesVisible NOTIFY shadesVisibleChanged)
+                //TODO: make wrapping of color for qml
                 Q_PROPERTY(QColor shadesColor READ shadesColor WRITE setShadesColor NOTIFY shadesColorChanged)
+                //TODO: make wrapping of border for qml
                 Q_PROPERTY(QColor shadesBorderColor READ shadesBorderColor WRITE setShadesBorderColor NOTIFY shadesBorderColorChanged)
+                Q_PROPERTY(QPen shadesPen READ shadesPen WRITE setShadesPen NOTIFY shadesPenChanged)
+                Q_PROPERTY(QBrush shadesBrush READ shadesBrush WRITE setShadesBrush NOTIFY shadesBrushChanged)
+                //title
+                Q_PROPERTY(QString titleText READ titleText WRITE setTitleText NOTIFY titleTextChanged)
+                Q_PROPERTY(QPen titlePen READ titlePen WRITE setTitlePen NOTIFY titlePenChanged)
+                Q_PROPERTY(QBrush titleBrush READ titleBrush WRITE setTitleBrush NOTIFY titleBrushChanged)
                 Q_PROPERTY(bool titleVisible READ titleVisible WRITE setTitleVisible)
                 Q_PROPERTY(QFont titleFont READ titleFont WRITE setTitleFont)
-                Q_PROPERTY(QString title READ title WRITE setTitle)
-                Q_PROPERTY(Qt::Alignment alignment READ alignment WRITE setAlignment)
             public:
                 virtual AxisType type() const = 0;
-                //visibilty handling
+                //visibility handling
                 bool isVisible() const;
                 void setVisible(bool visible = true);
+                void show();
+                void hide();
+                //arrow handling
-                //axis handling
                 bool isLineVisible() const;
                 void setLineVisible(bool visible = true);
                 void setLinePen(const QPen &pen);
                 QBrush titleBrush() const;
                 void setTitleFont(const QFont &font);
                 QFont titleFont() const;
-                void setTitle(const QString &title);
+                void setTitleText(const QString &title);
-                QString title() const;
+                QString titleText() const;
                 //shades handling
                 bool shadesVisible() const;
                 void setShadesBorderColor(QColor color);
                 QColor shadesBorderColor() const;
-                Qt::Orientation orientation();
+                Qt::Orientation orientation(); //TODO: missing const <- BC
                 Qt::Alignment alignment() const;
-                void setAlignment(Qt::Alignment alignment);
                 //range handling
                 void setMin(const QVariant &min);
                 void setMax(const QVariant &max);
                 void setRange(const QVariant &min, const QVariant &max);
-                void show();
-                void hide();
             Q_SIGNALS:
                 void visibleChanged(bool visible);
+                void linePenChanged(const QPen& pen);
                 void lineVisibleChanged(bool visible);
                 void labelsVisibleChanged(bool visible);
-                void gridVisibleChanged(bool visible);
+                void labelsPenChanged(const QPen& pen);
+                void labelsBrushChanged(const QBrush& brush);
+                void labelsFontChanged(const QFont& pen);
+                void labelsAngleChanged(int angle);
+                void gridLinePenChanged(const QPen& pen);
+                void gridLineVisibleChanged(bool visible);
                 void colorChanged(QColor color);
                 void labelsColorChanged(QColor color);
+                void titleTextChanged(const QString& title);
+                void titlePenChanged(const QPen& pen);
+                void titleBrushChanged(const QBrush brush);
+                void titleVisibleChanged(bool visible);
+                void titleFontChanged(const QFont& font);
                 void shadesVisibleChanged(bool visible);
                 void shadesColorChanged(QColor color);
                 void shadesBorderColorChanged(QColor color);
+                void shadesPenChanged(const QPen& pen);
+                void shadesBrushChanged(const QBrush brush);
             protected:
                 QScopedPointer<QAbstractAxisPrivate> d_ptr;
                 friend class ChartDataSet;
                 friend class ChartAxis;
                 friend class ChartPresenter;
+                friend class ChartThemeManager;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qabstractaxis_p.h +32 -19

             #define QABSTRACTAXIS_P_H
             #include "qabstractaxis.h"
+            #include "chartaxis_p.h"
+            #include "qchart.h"
+            #include <QDebug>
+            class QGraphicsItem;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
-            class ChartAxis;
             class Domain;
-            class ChartDataSet;
+            class QChart;
+            class QAbstractSeries;
+            class ChartTheme;
+            class ChartElement;
             class QTCOMMERCIALCHART_AUTOTEST_EXPORT QAbstractAxisPrivate : public QObject
             {
                 ~QAbstractAxisPrivate();
             public:
-                virtual ChartAxis *createGraphics(ChartPresenter *presenter) = 0;
+                Qt::Alignment alignment() const { return m_alignment; }
-                virtual void intializeDomain(Domain *domain) = 0;
-                void emitUpdated();
-                void setDirty(bool dirty);
-                bool isDirty() { return m_dirty; }
-                void setOrientation(Qt::Orientation orientation);
                 Qt::Orientation orientation() const { return m_orientation; }
+                void setAlignment( Qt::Alignment alignment);
-                virtual void setMin(const QVariant &min) = 0;
+                virtual void initializeDomain(Domain *domain) = 0;
-                virtual qreal min() = 0;
+                virtual void initializeGraphics(QGraphicsItem* parent) = 0;
+                virtual void initializeTheme(ChartTheme* theme, bool forced = false);
+                virtual void initializeAnimations(QChart::AnimationOptions options);
+                //interface for manipulating range form base class
+                virtual void setMin(const QVariant &min) = 0;
                 virtual void setMax(const QVariant &max) = 0;
-                virtual qreal max() = 0;
+                virtual void setRange(const QVariant &min, const QVariant &max) = 0;
-                virtual int count() const = 0;
+                //interface manipulating range form domain
+                virtual void setRange(qreal min, qreal max) = 0;
+                virtual qreal min() = 0;
+                virtual qreal max() = 0;
-                virtual void setRange(const QVariant &min, const QVariant &max) = 0;
+                ChartAxis* axisItem() { return m_item.data(); }
             public Q_SLOTS:
-                virtual void handleDomainUpdated() = 0;
+                void handleRangeChanged(qreal min, qreal max);
             Q_SIGNALS:
-                void updated();
+                void rangeChanged(qreal min, qreal max);
             protected:
                 QAbstractAxis *q_ptr;
-                Qt::Orientation m_orientation;
+                QChart *m_chart;
+                QScopedPointer<ChartAxis> m_item;
+            private:
+                QList<QAbstractSeries*> m_series;
                 Qt::Alignment m_alignment;
-                ChartDataSet *m_dataset;
+                Qt::Orientation m_orientation;
-            private:
                 bool m_visible;
                 bool m_arrowVisible;
                 friend class QAbstractAxis;
                 friend class ChartDataSet;
+                friend class ChartPresenter;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/chartvalueaxisx.cpp +26 -18

             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartValueAxisX::ChartValueAxisX(QValueAxis *axis, ChartPresenter *presenter)
+            ChartValueAxisX::ChartValueAxisX(QValueAxis *axis, QGraphicsItem* item )
-                : HorizontalAxis(axis, presenter),
+                : HorizontalAxis(axis, item),
-                  m_tickCount(0), m_axis(axis)
+                  m_axis(axis)
             {
+            	QObject::connect(m_axis,SIGNAL(tickCountChanged(int)),this, SLOT(handleTickCountChanged(int)));
             }
             ChartValueAxisX::~ChartValueAxisX()
             QVector<qreal> ChartValueAxisX::calculateLayout() const
             {
-                Q_ASSERT(m_tickCount >= 2);
+            	int tickCount = m_axis->tickCount();
+                Q_ASSERT(tickCount >= 2);
                 QVector<qreal> points;
-                points.resize(m_tickCount);
+                points.resize(tickCount);
                 const QRectF &gridRect = gridGeometry();
-                const qreal deltaX = gridRect.width() / (m_tickCount - 1);
+                const qreal deltaX = gridRect.width() / (tickCount - 1);
-                for (int i = 0; i < m_tickCount; ++i) {
+                for (int i = 0; i < tickCount; ++i) {
                     points[i] = i * deltaX + gridRect.left();
                 }
                 return points;
                 const QVector<qreal>& layout = ChartAxis::layout();
                 if (layout.isEmpty())
                     return;
-                setLabels(createValueLabels(layout.size()));
+                setLabels(createValueLabels(min(),max(),layout.size(),m_axis->labelFormat()));
                 HorizontalAxis::updateGeometry();
             }
-            void ChartValueAxisX::handleAxisUpdated()
+            void ChartValueAxisX::handleTickCountChanged(int tick)
             {
-                if (m_tickCount != m_axis->tickCount()) {
+            	Q_UNUSED(tick);
-                    m_tickCount = m_axis->tickCount();
+                if(presenter()) presenter()->layout()->invalidate();
-                    presenter()->layout()->invalidate();
+                //QVector<qreal> layout = calculateLayout();
+                //updateLayout(layout);
-                ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartValueAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
-                QStringList ticksList = createValueLabels(m_tickCount);
+                QStringList ticksList = createValueLabels(min(),max(),m_axis->tickCount(),m_axis->labelFormat());
                 qreal width = 0;
                 qreal height = 0;
+                int count = 1;
+                if(!ticksList.empty()) {
+                    count = qMax(ticksList.last().count(),ticksList.first().count());
+                }
                 switch (which) {
                 case Qt::MinimumSize:{
-                    int count = qMax(ticksList.last().count(),ticksList.first().count());
                     count = qMin(count,5);
                     width = fn.averageCharWidth() * count;
                     height = fn.height() + labelPadding();
                     break;
                 }
                 case Qt::PreferredSize:{
-                    int count = qMax(ticksList.last().count(),ticksList.first().count());
                     width=fn.averageCharWidth() * count;
                     height=fn.height()+labelPadding();
                     width=qMax(width,base.width());
                 return sh;
             }
+            #include "moc_chartvalueaxisx_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/chartvalueaxisx_p.h +5 -6

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

src/axis/valueaxis/chartvalueaxisy.cpp +24 -17

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartValueAxisY::ChartValueAxisY(QValueAxis *axis, ChartPresenter *presenter)
+            ChartValueAxisY::ChartValueAxisY(QValueAxis *axis, QGraphicsItem* item)
-                : VerticalAxis(axis, presenter),
+                : VerticalAxis(axis, item),
-                  m_tickCount(0),
                   m_axis(axis)
             {
+            	QObject::connect(m_axis,SIGNAL(tickCountChanged(int)),this, SLOT(handleTickCountChanged(int)));
             }
             ChartValueAxisY::~ChartValueAxisY()
             QVector<qreal> ChartValueAxisY::calculateLayout() const
             {
-                Q_ASSERT(m_tickCount >= 2);
+            	int tickCount = m_axis->tickCount();
+                Q_ASSERT(tickCount >= 2);
                 QVector<qreal> points;
-                points.resize(m_tickCount);
+                points.resize(tickCount);
                 const QRectF &gridRect = gridGeometry();
-                const qreal deltaY = gridRect.height() / (m_tickCount - 1);
+                const qreal deltaY = gridRect.height() / (tickCount - 1);
-                for (int i = 0; i < m_tickCount; ++i) {
+                for (int i = 0; i < tickCount; ++i) {
                     points[i] = i * -deltaY + gridRect.bottom();
                 }
                 const QVector<qreal> &layout = ChartAxis::layout();
                 if (layout.isEmpty())
                     return;
-                setLabels(createValueLabels(layout.size()));
+                setLabels(createValueLabels(min(),max(),layout.size(),m_axis->labelFormat()));
                 VerticalAxis::updateGeometry();
             }
-            void ChartValueAxisY::handleAxisUpdated()
+            void ChartValueAxisY::handleTickCountChanged(int tick)
             {
-                if (m_tickCount != m_axis->tickCount()) {
+            	Q_UNUSED(tick);
-                    m_tickCount = m_axis->tickCount();
+            	if(presenter()) presenter()->layout()->invalidate();
-                    presenter()->layout()->invalidate();
+            	//QVector<qreal> layout = calculateLayout();
+            	//updateLayout(layout);
-                ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartValueAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
                 QFontMetrics fn(font());
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
-                QStringList ticksList = createValueLabels(m_tickCount);
+                QStringList ticksList = createValueLabels(min(),max(),m_axis->tickCount(),m_axis->labelFormat());
                 qreal width = 0;
                 qreal height = 0;
+                int count = 1;
+                if(!ticksList.empty()){
+                    count = qMax(ticksList.last().count(),ticksList.first().count());
+                }
                 switch (which) {
                 case Qt::MinimumSize: {
                     width = fn.boundingRect("...").width() + labelPadding();
                 }
                 case Qt::PreferredSize:
                 {
-                    int count = qMax(ticksList.first().count() , ticksList.last().count());
                     width = count*fn.averageCharWidth() + labelPadding() + 2; //two pixels of tolerance
                     width += base.width();
                     height = fn.height() * ticksList.count();
                 return sh;
             }
+            #include "moc_chartvalueaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/chartvalueaxisy_p.h +4 -3

             class ChartValueAxisY : public VerticalAxis
             {
+            	Q_OBJECT
             public:
-                ChartValueAxisY(QValueAxis *axis, ChartPresenter *presenter);
+                ChartValueAxisY(QValueAxis *axis, QGraphicsItem* item = 0);
                 ~ChartValueAxisY();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();
-                void handleAxisUpdated();
+            private Q_SLOTS:
+                void handleTickCountChanged(int tick);
             private:
-                int m_tickCount;
                 QValueAxis *m_axis;
             };

src/axis/valueaxis/qvalueaxis.cpp +69 -100

@@ -24,7 +24,8
24	#include "chartvalueaxisy_p.h"	24	#include "chartvalueaxisy_p.h"
25	#include "domain_p.h"	25	#include "domain_p.h"
26	#include "chartdataset_p.h"	26	#include "chartdataset_p.h"
27	#include <qmath.h>	27	#include "chartpresenter_p.h"
		28	#include "charttheme_p.h"
28		29
29		30
30	QTCOMMERCIALCHART_BEGIN_NAMESPACE	31	QTCOMMERCIALCHART_BEGIN_NAMESPACE
@@ -174,8 +175,8 QValueAxis::QValueAxis(QValueAxisPrivate &d, QObject *parent)
174	QValueAxis::~QValueAxis()	175	QValueAxis::~QValueAxis()
175	{	176	{
176	Q_D(QValueAxis);	177	Q_D(QValueAxis);
177	if (d->m_~~datase~~t)	178	if (d->m_chart)
178	d->m_~~datase~~t->removeAxis(this);	179	d->m_chart->removeAxis(this);
179	}	180	}
180		181
181	void QValueAxis::setMin(qreal min)	182	void QValueAxis::setMin(qreal min)
@@ -209,34 +210,7 qreal QValueAxis::max() const
209	void QValueAxis::setRange(qreal min, qreal max)	210	void QValueAxis::setRange(qreal min, qreal max)
210	{	211	{
211	Q_D(QValueAxis);	212	Q_D(QValueAxis);
212	bool changed = false;	213	d->setRange(min,max);
213
214	if (min > max)
215	return;
216
217	if (d->m_niceNumbers) {
218	int ticks = d->m_tickCount;
219	d->looseNiceNumbers(min, max, ticks);
220	if (ticks != d->m_tickCount)
221	setTickCount(ticks);
222	}
223
224	if (!qFuzzyCompare(d->m_min, min)) {
225	d->m_min = min;
226	changed = true;
227	emit minChanged(min);
228	}
229
230	if (!qFuzzyCompare(d->m_max, max)) {
231	d->m_max = max;
232	changed = true;
233	emit maxChanged(max);
234	}
235
236	if (changed) {
237	emit rangeChanged(min, max);
238	d->emitUpdated();
239	}
240	}	214	}
241		215
242	/*!	216	/*!
@@ -247,7 +221,7 void QValueAxis::setTickCount(int count)
247	Q_D(QValueAxis);	221	Q_D(QValueAxis);
248	if (d->m_tickCount != count && count >= 2) {	222	if (d->m_tickCount != count && count >= 2) {
249	d->m_tickCount = count;	223	d->m_tickCount = count;
250	d->emitUpdated();	224	emit tickCountChanged(count);
251	}	225	}
252	}	226	}
253		227
@@ -263,18 +237,14 int QValueAxis::tickCount() const
263		237
264	void QValueAxis::setNiceNumbersEnabled(bool enable)	238	void QValueAxis::setNiceNumbersEnabled(bool enable)
265	{	239	{
266	Q_D(~~QValueAxis~~);	240	Q_UNUSED(enable);
267	if (d->m_niceNumbers != enable) {	241	qWarning()<<"This function is depreciated.Use applyNiceNumbers().";
268	d->m_niceNumbers = enable;
269	if (enable && !qFuzzyCompare(d->m_max, d->m_min))
270	setRange(d->m_min, d->m_max);
271	}
272	}	242	}
273		243
274	bool QValueAxis::niceNumbersEnabled() const	244	bool QValueAxis::niceNumbersEnabled() const
275	{	245	{
276	Q_D(const QValueAxis);	246	qWarning()<<"This function is depreciated.Use applyNiceNumbers().";
277	return d->m_niceNumbers;	247	return false;
278	}	248	}
279		249
280	void QValueAxis::setLabelFormat(const QString &format)	250	void QValueAxis::setLabelFormat(const QString &format)
@@ -297,6 +267,17 QAbstractAxis::AxisType QValueAxis::type() const
297	return AxisTypeValue;	267	return AxisTypeValue;
298	}	268	}
299		269
		270	void QValueAxis::applyNiceNumbers()
		271	{
		272	Q_D(QValueAxis);
		273	qreal min = d->m_min;
		274	qreal max = d->m_max;
		275	int ticks = d->m_tickCount;
		276	Domain::looseNiceNumbers(min,max,ticks);
		277	d->setRange(min,max);
		278	setTickCount(ticks);
		279	}
		280
300	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	281	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
301		282
302	QValueAxisPrivate::QValueAxisPrivate(QValueAxis *q)	283	QValueAxisPrivate::QValueAxisPrivate(QValueAxis *q)
@@ -304,7 +285,6 QValueAxisPrivate::QValueAxisPrivate(QValueAxis *q)
304	m_min(0),	285	m_min(0),
305	m_max(0),	286	m_max(0),
306	m_tickCount(5),	287	m_tickCount(5),
307	m_niceNumbers(false),
308	m_format(QString::null)	288	m_format(QString::null)
309	{	289	{
310		290
@@ -315,19 +295,6 QValueAxisPrivate::~QValueAxisPrivate()
315		295
316	}	296	}
317		297
318	void QValueAxisPrivate::handleDomainUpdated()
319	{
320	Q_Q(QValueAxis);
321	Domain domain = qobject_cast<Domain >(sender());
322	Q_ASSERT(domain);
323
324	if (orientation() == Qt::Horizontal)
325	q->setRange(domain->minX(), domain->maxX());
326	else if (orientation() == Qt::Vertical)
327	q->setRange(domain->minY(), domain->maxY());
328	}
329
330
331	void QValueAxisPrivate::setMin(const QVariant &min)	298	void QValueAxisPrivate::setMin(const QVariant &min)
332	{	299	{
333	Q_Q(QValueAxis);	300	Q_Q(QValueAxis);
@@ -358,62 +325,64 void QValueAxisPrivate::setRange(const QVariant &min, const QVariant &max)
358	q->setRange(value1, value2);	325	q->setRange(value1, value2);
359	}	326	}
360		327
361	ChartAxis QValueAxisPrivate::createGraphics(ChartPresenter presenter)	328	void QValueAxisPrivate::setRange(qreal min, qreal max)
362	{	329	{
363	Q_Q(QValueAxis);	330	Q_Q(QValueAxis);
364	if (m_orientation == Qt::Vertical)	331	bool changed = false;
365	return new ChartValueAxisY(q, presenter);
366	return new ChartValueAxisX(q, presenter);
367	}
368		332
369	void QValueAxisPrivate::intializeDomain(Domain *domain)	333	if (min > max)
370	{	334	return;
371	Q_Q(QValueAxis);	335
372	if (qFuzzyCompare(m_max, m_min)) {	336	if (!qFuzzyCompare(m_min,min)) {
373	if (m_orientation == Qt::Vertical)	337	m_min = min;
374	q->setRange(domain->minY(), domain->maxY());	338	changed = true;
375	else	339	emit q->minChanged(min);
376	q->setRange(domain->minX(), domain->maxX());	340	}
377	} else {	341
378	if (m_orientation == Qt::Vertical)	342	if (!qFuzzyCompare(m_max,max)) {
379	domain->setRangeY(m_min, m_max);	343	m_max = max;
380	else	344	changed = true;
381	domain->setRangeX(m_min, m_max);	345	emit q->maxChanged(max);
382	}	346	}
383	}
384		347
385	//algorithm defined by Paul S.Heckbert GraphicalGems I	348	if (changed) {
		349	emit q->rangeChanged(min, max);
		350	emit rangeChanged(min,max);
		351	}
		352	}
386		353
387	void QValueAxisPrivate::looseNiceNumbers(qreal &min, qreal &max, int &ticksCount) const	354	void QValueAxisPrivate::initializeGraphics(QGraphicsItem* parent)
388	{	355	{
389	qreal range = niceNumber(max - min, true); //range with ceiling	356	Q_Q(QValueAxis);
390	qreal step = niceNumber(range / (ticksCount - 1), false);	357	ChartAxis* axis(0);
391	min = qFloor(min / step);	358	if (orientation() == Qt::Vertical)
392	max = qCeil(max / step);	359	axis = new ChartValueAxisY(q,parent);
393	ticksCount = int(max - min) + 1;	360	if (orientation() == Qt::Horizontal)
394	min *= step;	361	axis = new ChartValueAxisX(q,parent);
395	max *= step;	362
		363	m_item.reset(axis);
		364	QAbstractAxisPrivate::initializeGraphics(parent);
396	}	365	}
397		366
398	//nice numbers can be expressed as form of 110^n, 2 10^n or 5*10^n
399		367
400	qreal QValueAxisPrivate::niceNumber(qreal x, bool ceiling) const	368	void QValueAxisPrivate::initializeDomain(Domain *domain)
401	{	369	{
402	qreal z = qPow(10, qFloor(log10(x))); //find corresponding number of the form of 10^n than is smaller than x	370	if (orientation() == Qt::Vertical) {
403	qreal q = x / z; //q<10 && q>=1;	371	if(!qFuzzyIsNull(m_max - m_min)) {
404		372	domain->setRangeY(m_min, m_max);
405	if (ceiling) {	373	}
406	if (q <= 1.0) q = 1;	374	else {
407	else if (q <= 2.0) q = 2;	375	setRange(domain->minY(), domain->maxY());
408	else if (q <= 5.0) q = 5;	376	}
409	else q = 10;	377	}
410	} else {	378	if (orientation() == Qt::Horizontal) {
411	if (q < 1.5) q = 1;	379	if(!qFuzzyIsNull(m_max - m_min)) {
412	else if (q < 3.0) q = 2;	380	domain->setRangeX(m_min, m_max);
413	else if (q < 7.0) q = 5;	381	}
414	else q = 10;	382	else {
		383	setRange(domain->minX(), domain->maxX());
		384	}
415	}	385	}
416	return q * z;
417	}	386	}
418		387
419	#include "moc_qvalueaxis.cpp"	388	#include "moc_qvalueaxis.cpp"

src/axis/valueaxis/qvalueaxis.h +5 -1

             class QTCOMMERCIALCHART_EXPORT QValueAxis : public QAbstractAxis
             {
                 Q_OBJECT
-                Q_PROPERTY(int tickCount READ tickCount WRITE setTickCount)
+                Q_PROPERTY(int tickCount READ tickCount WRITE setTickCount NOTIFY tickCountChanged)
                 Q_PROPERTY(bool niceNumbersEnabled READ niceNumbersEnabled WRITE setNiceNumbersEnabled)
                 Q_PROPERTY(qreal min READ min WRITE setMin NOTIFY minChanged)
                 Q_PROPERTY(qreal max READ max WRITE setMax NOTIFY maxChanged)
                 void setLabelFormat(const QString &format);
                 QString labelFormat() const;
+                void applyNiceNumbers();
+                //TODO: depreciated !
                 void setNiceNumbersEnabled(bool enable = true);
                 bool niceNumbersEnabled() const;
                 void minChanged(qreal min);
                 void maxChanged(qreal max);
                 void rangeChanged(qreal min, qreal max);
+                void tickCountChanged(int ticks);
             private:
                 Q_DECLARE_PRIVATE(QValueAxis)

src/axis/valueaxis/qvalueaxis_p.h +4 -9

                 ~QValueAxisPrivate();
             public:
-                ChartAxis *createGraphics(ChartPresenter *presenter);
+                void initializeGraphics(QGraphicsItem* parent);
-                void intializeDomain(Domain *domain);
+                void initializeDomain(Domain *domain);
-                void handleDomainUpdated();
                 qreal min() { return m_min; };
                 qreal max() { return m_max; };
-                int count() const { return m_tickCount; }
+                void setRange(qreal min,qreal max);
             protected:
                 void setMin(const QVariant &min);
                 void setRange(const QVariant &min, const QVariant &max);
             private:
-                void looseNiceNumbers(qreal &min, qreal &max, int &ticksCount) const;
-                qreal niceNumber(qreal x, bool ceiling) const;
-            private:
                 qreal m_min;
                 qreal m_max;
                 int m_tickCount;
-                bool m_niceNumbers;
                 QString m_format;
                 Q_DECLARE_PUBLIC(QValueAxis)
             };

src/axis/verticalaxis.cpp +3 -3

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            VerticalAxis::VerticalAxis(QAbstractAxis *axis, ChartPresenter *presenter, bool intervalAxis)
+            VerticalAxis::VerticalAxis(QAbstractAxis *axis, QGraphicsItem* item, bool intervalAxis)
-                : ChartAxis(axis, presenter, intervalAxis)
+                : ChartAxis(axis, item, intervalAxis)
             {
             }
                     break;
                 case Qt::MaximumSize:
                 case Qt::PreferredSize:
-                        sh = QSizeF(fn.height(), fn.boundingRect(axis()->title()).width());
+                        sh = QSizeF(fn.height(), fn.boundingRect(axis()->titleText()).width());
                     break;
                 default:
                     break;

src/axis/verticalaxis_p.h +1 -1

             class VerticalAxis : public ChartAxis
             {
             public:
-                VerticalAxis(QAbstractAxis *axis, ChartPresenter *presenter, 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/barchart/abstractbarchartitem.cpp +10 -9

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            AbstractBarChartItem::AbstractBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
+            AbstractBarChartItem::AbstractBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
-                ChartItem(presenter),
+                ChartItem(series->d_func(),item),
                 m_animation(0),
                 m_series(series)
             {
                 m_domainMaxX = domain()->maxX();
                 m_domainMinY = domain()->minY();
                 m_domainMaxY = domain()->maxY();
-                handleLayoutChanged();
-            void AbstractBarChartItem::handleGeometryChanged(const QRectF &rect)
+                QRectF rect(QPointF(0,0),domain()->size());
-                prepareGeometryChange();
+                if(m_rect != rect){
-                m_rect = rect;
+                    prepareGeometryChange();
+                    m_rect = rect;
+                }
                 handleLayoutChanged();
             }
                     }
                 }
-                presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
+                if(themeManager()) themeManager()->updateSeries(m_series);
                 handleLayoutChanged();
             }

src/barchart/abstractbarchartitem_p.h +1 -2

             {
                 Q_OBJECT
             public:
-                AbstractBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
+                AbstractBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item = 0);
                 virtual ~AbstractBarChartItem();
             public:
             public Q_SLOTS:
                 void handleDomainUpdated();
-                void handleGeometryChanged(const QRectF &size);
                 void handleLayoutChanged();
                 void handleLabelsVisibleChanged(bool visible);
                 void handleDataStructureChanged();     // structure of of series has changed, recreate graphic items

src/barchart/horizontal/bar/horizontalbarchartitem.cpp +2 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            HorizontalBarChartItem::HorizontalBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter)
+            HorizontalBarChartItem::HorizontalBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item)
-                : AbstractBarChartItem(series, presenter)
+                : AbstractBarChartItem(series, item)
             {
             }

src/barchart/horizontal/bar/horizontalbarchartitem_p.h +1 -1

             {
                 Q_OBJECT
             public:
-                HorizontalBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
+                HorizontalBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item = 0);
             private:
                 virtual QVector<QRectF> calculateLayout();

src/barchart/horizontal/bar/qhorizontalbarseries.cpp +22 -13

             QHorizontalBarSeries::~QHorizontalBarSeries()
             {
                 Q_D(QHorizontalBarSeries);
-                if (d->m_dataset)
+                if (d->m_chart)
-                    d->m_dataset->removeSeries(this);
+                    d->m_chart->removeSeries(this);
             }
             /*!
             }
-            void QHorizontalBarSeriesPrivate::scaleDomain(Domain &domain)
+            void QHorizontalBarSeriesPrivate::initializeDomain()
             {
-                qreal minX(domain.minX());
+                qreal minX(domain()->minX());
-                qreal minY(domain.minY());
+                qreal minY(domain()->minY());
-                qreal maxX(domain.maxX());
+                qreal maxX(domain()->maxX());
-                qreal maxY(domain.maxY());
+                qreal maxY(domain()->maxY());
                 qreal y = categoryCount();
                 minX = qMin(minX, min());
                 maxX = qMax(maxX, max());
                 maxY = qMax(maxY, y - (qreal)0.5);
-                domain.setRange(minX, maxX, minY, maxY);
+                domain()->setRange(minX, maxX, minY, maxY);
             }
-            ChartElement *QHorizontalBarSeriesPrivate::createGraphics(ChartPresenter *presenter)
+            void QHorizontalBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QHorizontalBarSeries);
+                HorizontalBarChartItem *bar = new HorizontalBarChartItem(q,parent);
+                m_item.reset(bar);
+                QAbstractSeriesPrivate::initializeGraphics(parent);
+            }
-                HorizontalBarChartItem *bar = new HorizontalBarChartItem(q, presenter);
+            void QHorizontalBarSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
-                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
+                HorizontalBarChartItem *bar = static_cast<HorizontalBarChartItem *>(m_item.data());
+                Q_ASSERT(bar);
+                if (options.testFlag(QChart::SeriesAnimations)) {
                     bar->setAnimation(new HorizontalBarAnimation(bar));
-                presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
+                }else{
-                return bar;
+                    bar->setAnimation(0);
+                }
+                QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qhorizontalbarseries.cpp"

src/barchart/horizontal/bar/qhorizontalbarseries_p.h +3 -2

             {
             public:
                 QHorizontalBarSeriesPrivate(QHorizontalBarSeries *q);
-                ChartElement *createGraphics(ChartPresenter *presenter);
+                void initializeGraphics(QGraphicsItem* parent);
-                void scaleDomain(Domain &domain);
+                void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
+                void initializeDomain();
             private:
                 Q_DECLARE_PUBLIC(QHorizontalBarSeries)
             };

src/barchart/horizontal/percent/horizontalpercentbarchartitem.cpp +2 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            HorizontalPercentBarChartItem::HorizontalPercentBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter)
+            HorizontalPercentBarChartItem::HorizontalPercentBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item)
-                : AbstractBarChartItem(series, presenter)
+                : AbstractBarChartItem(series, item)
             {
             }

src/barchart/horizontal/percent/horizontalpercentbarchartitem_p.h +1 -1

             {
                 Q_OBJECT
             public:
-                HorizontalPercentBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
+                HorizontalPercentBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item = 0);
             private:
                 virtual QVector<QRectF> calculateLayout();

src/barchart/horizontal/percent/qhorizontalpercentbarseries.cpp +22 -14

             QHorizontalPercentBarSeries::~QHorizontalPercentBarSeries()
             {
                 Q_D(QHorizontalPercentBarSeries);
-                if (d->m_dataset)
+                if (d->m_chart)
-                    d->m_dataset->removeSeries(this);
+                    d->m_chart->removeSeries(this);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             }
-            void QHorizontalPercentBarSeriesPrivate::scaleDomain(Domain &domain)
+            void QHorizontalPercentBarSeriesPrivate::initializeDomain()
             {
-                qreal minX(domain.minX());
+                qreal minX(domain()->minX());
-                qreal minY(domain.minY());
+                qreal minY(domain()->minY());
-                qreal maxX(domain.maxX());
+                qreal maxX(domain()->maxX());
-                qreal maxY(domain.maxY());
+                qreal maxY(domain()->maxY());
                 qreal y = categoryCount();
                 minX = 0;
                 minY = qMin(minY, - (qreal)0.5);
                 maxY = qMax(maxY, y - (qreal)0.5);
-                domain.setRange(minX, maxX, minY, maxY);
+                domain()->setRange(minX, maxX, minY, maxY);
             }
-            ChartElement *QHorizontalPercentBarSeriesPrivate::createGraphics(ChartPresenter *presenter)
+            void QHorizontalPercentBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QHorizontalPercentBarSeries);
+                HorizontalPercentBarChartItem *bar = new HorizontalPercentBarChartItem(q,parent);
+                m_item.reset(bar);
+                QAbstractSeriesPrivate::initializeGraphics(parent);
+            }
-                HorizontalPercentBarChartItem *bar = new HorizontalPercentBarChartItem(q, presenter);
+            void QHorizontalPercentBarSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
-                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
+                HorizontalPercentBarChartItem *bar = static_cast<HorizontalPercentBarChartItem *>(m_item.data());
+                Q_ASSERT(bar);
+                if (options.testFlag(QChart::SeriesAnimations)) {
                     bar->setAnimation(new HorizontalPercentBarAnimation(bar));
-                presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
+                }else{
-                return bar;
+                    bar->setAnimation(0);
+                }
+                QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qhorizontalpercentbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/percent/qhorizontalpercentbarseries_p.h +3 -2

             {
             public:
                 QHorizontalPercentBarSeriesPrivate(QHorizontalPercentBarSeries *q);
-                ChartElement *createGraphics(ChartPresenter *presenter);
+                void initializeGraphics(QGraphicsItem* parent);
-                void scaleDomain(Domain &domain);
+                void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
+                void initializeDomain();
             private:
                 Q_DECLARE_PUBLIC(QHorizontalPercentBarSeries)
             };

src/barchart/horizontal/stacked/horizontalstackedbarchartitem.cpp +2 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            HorizontalStackedBarChartItem::HorizontalStackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter)
+            HorizontalStackedBarChartItem::HorizontalStackedBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item)
-                : AbstractBarChartItem(series, presenter)
+                : AbstractBarChartItem(series, item)
             {
             }

src/barchart/horizontal/stacked/horizontalstackedbarchartitem_p.h +1 -1

             {
                 Q_OBJECT
             public:
-                HorizontalStackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
+                HorizontalStackedBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item = 0);
             private:
                 virtual QVector<QRectF> calculateLayout();

src/barchart/horizontal/stacked/qhorizontalstackedbarseries.cpp +22 -14

             QHorizontalStackedBarSeries::~QHorizontalStackedBarSeries()
             {
                 Q_D(QHorizontalStackedBarSeries);
-                if (d->m_dataset)
+                if (d->m_chart)
-                    d->m_dataset->removeSeries(this);
+                    d->m_chart->removeSeries(this);
             }
             /*!
             }
-            void QHorizontalStackedBarSeriesPrivate::scaleDomain(Domain &domain)
+            void QHorizontalStackedBarSeriesPrivate::initializeDomain()
             {
-                qreal minX(domain.minX());
+                qreal minX(domain()->minX());
-                qreal minY(domain.minY());
+                qreal minY(domain()->minY());
-                qreal maxX(domain.maxX());
+                qreal maxX(domain()->maxX());
-                qreal maxY(domain.maxY());
+                qreal maxY(domain()->maxY());
                 qreal y = categoryCount();
                 minX = qMin(minX, bottom());
                 maxX = qMax(maxX, top());
                 maxY = qMax(maxY, y - (qreal)0.5);
-                domain.setRange(minX, maxX, minY, maxY);
+                domain()->setRange(minX, maxX, minY, maxY);
             }
-            ChartElement *QHorizontalStackedBarSeriesPrivate::createGraphics(ChartPresenter *presenter)
+            void QHorizontalStackedBarSeriesPrivate::initializeGraphics(QGraphicsItem *parent)
             {
                 Q_Q(QHorizontalStackedBarSeries);
+                HorizontalStackedBarChartItem *bar = new HorizontalStackedBarChartItem(q,parent);
+                m_item.reset(bar);
+                QAbstractSeriesPrivate::initializeGraphics(parent);
+            }
-                HorizontalStackedBarChartItem *bar = new HorizontalStackedBarChartItem(q, presenter);
+            void QHorizontalStackedBarSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
-                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
+                HorizontalStackedBarChartItem *bar = static_cast<HorizontalStackedBarChartItem *>(m_item.data());
+                Q_ASSERT(bar);
+                if (options.testFlag(QChart::SeriesAnimations)) {
                     bar->setAnimation(new HorizontalStackedBarAnimation(bar));
-                presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
+                }else{
-                return bar;
+                    bar->setAnimation(0);
+                }
+                QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qhorizontalstackedbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/stacked/qhorizontalstackedbarseries_p.h +3 -2

             {
             public:
                 QHorizontalStackedBarSeriesPrivate(QHorizontalStackedBarSeries *q);
-                ChartElement *createGraphics(ChartPresenter *presenter);
+                void initializeGraphics(QGraphicsItem* parent);
-                void scaleDomain(Domain &domain);
+                void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
+                void initializeDomain();
             private:
                 Q_DECLARE_PUBLIC(QHorizontalStackedBarSeries)
             };

src/barchart/qabstractbarseries.cpp +76 -29

@@ -622,12 +622,12 qreal QAbstractBarSeriesPrivate::bottom()
622	}	622	}
623		623
624		624
625	void QAbstractBarSeriesPrivate::~~scal~~eDomain(~~Domain~~ &~~domain~~)	625	void QAbstractBarSeriesPrivate::initializeDomain()
626	{	626	{
627	qreal minX(domain.minX());	627	qreal minX(domain()->minX());
628	qreal minY(domain.minY());	628	qreal minY(domain()->minY());
629	qreal maxX(domain.maxX());	629	qreal maxX(domain()->maxX());
630	qreal maxY(domain.maxY());	630	qreal maxY(domain()->maxY());
631		631
632	qreal seriesMinX = this->minX();	632	qreal seriesMinX = this->minX();
633	qreal seriesMaxX = this->maxX();	633	qreal seriesMaxX = this->maxX();
@@ -637,14 +637,7 void QAbstractBarSeriesPrivate::scaleDomain(Domain &domain)
637	maxX = qMax(maxX, seriesMaxX + (qreal)0.5);	637	maxX = qMax(maxX, seriesMaxX + (qreal)0.5);
638	maxY = qMax(maxY, y);	638	maxY = qMax(maxY, y);
639		639
640	domain.setRange(minX, maxX, minY, maxY);	640	domain()->setRange(minX, maxX, minY, maxY);
641	}
642
643	ChartElement QAbstractBarSeriesPrivate::createGraphics(ChartPresenter presenter)
644	{
645	Q_UNUSED(presenter);
646	qWarning() << "QAbstractBarSeriesPrivate::createGraphics called";
647	return 0;
648	}	641	}
649		642
650	QList<QLegendMarker> QAbstractBarSeriesPrivate::createLegendMarkers(QLegend legend)	643	QList<QLegendMarker> QAbstractBarSeriesPrivate::createLegendMarkers(QLegend legend)
@@ -746,27 +739,30 bool QAbstractBarSeriesPrivate::insert(int index, QBarSet *set)
746	return true;	739	return true;
747	}	740	}
748		741
749	void QAbstractBarSeriesPrivate::initializeAxis(~~QAbstractAxis~~ *~~axis~~)	742	void QAbstractBarSeriesPrivate::initializeAxes()
750	{	743	{
751	Q_Q(QAbstractBarSeries);	744	Q_Q(QAbstractBarSeries);
752		745
753	if (axis->type() == QAbstractAxis::AxisTypeBarCategory) {	746	foreach(QAbstractAxis* axis, m_axes) {
754	switch (q->type()) {	747
755	case QAbstractSeries::SeriesTypeHorizontalBar:	748	if (axis->type() == QAbstractAxis::AxisTypeBarCategory) {
756	case QAbstractSeries::SeriesTypeHorizontalPercentBar:	749	switch (q->type()) {
757	case QAbstractSeries::SeriesTypeHorizontal~~Stacked~~Bar:	750	case QAbstractSeries::SeriesTypeHorizontalBar:
758	if (axis->orientation() == Qt::Vertical)	751	case QAbstractSeries::SeriesTypeHorizontalPercentBar:
		752	case QAbstractSeries::SeriesTypeHorizontalStackedBar:
		753	if (axis->orientation() == Qt::Vertical)
759	populateCategories(qobject_cast<QBarCategoryAxis *>(axis));	754	populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
760	break;	755	break;
761	case QAbstractSeries::SeriesTypeBar:	756	case QAbstractSeries::SeriesTypeBar:
762	case QAbstractSeries::SeriesTypePercentBar:	757	case QAbstractSeries::SeriesTypePercentBar:
763	case QAbstractSeries::SeriesTypeStackedBar:	758	case QAbstractSeries::SeriesTypeStackedBar:
764	if (axis->orientation() == Qt::Horizontal)	759	if (axis->orientation() == Qt::Horizontal)
765	populateCategories(qobject_cast<QBarCategoryAxis *>(axis));	760	populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
766	break;	761	break;
767	default:	762	default:
768	qWarning() << "Unexpected series type";	763	qWarning() << "Unexpected series type";
769	break;	764	break;
		765	}
770	}	766	}
771	}	767	}
772	}	768	}
@@ -806,6 +802,57 void QAbstractBarSeriesPrivate::populateCategories(QBarCategoryAxis *axis)
806	}	802	}
807	}	803	}
808		804
		805	QAbstractAxis* QAbstractBarSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
		806	{
		807	Q_UNUSED(orientation);
		808	return 0;
		809	}
		810
		811	void QAbstractBarSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
		812	{
		813	const QList<QGradient> gradients = theme->seriesGradients();
		814
		815	QBrush brush;
		816	QPen pen;
		817
		818	qreal takeAtPos = 0.5;
		819	qreal step = 0.2;
		820	if (m_barSets.count() > 1) {
		821	step = 1.0 / (qreal) m_barSets.count();
		822	if (m_barSets.count() % gradients.count())
		823	step *= gradients.count();
		824	else
		825	step *= (gradients.count() - 1);
		826	}
		827
		828	for (int i(0); i < m_barSets.count(); i++) {
		829	int colorIndex = (index + i) % gradients.count();
		830	if (i > 0 && i %gradients.count() == 0) {
		831	// There is no dedicated base color for each sets, generate more colors
		832	takeAtPos += step;
		833	if (takeAtPos == 1.0)
		834	takeAtPos += step;
		835	takeAtPos -= (int) takeAtPos;
		836	}
		837	if (forced \|\| brush == m_barSets.at(i)->brush())
		838	m_barSets.at(i)->setBrush(ChartThemeManager::colorAt(gradients.at(colorIndex), takeAtPos));
		839
		840	// Pick label color from the opposite end of the gradient.
		841	// 0.3 as a boundary seems to work well.
		842	if (forced \|\| brush == m_barSets.at(i)->labelBrush()) {
		843	if (takeAtPos < 0.3)
		844	m_barSets.at(i)->setLabelBrush(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 1));
		845	else
		846	m_barSets.at(i)->setLabelBrush(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0));
		847	}
		848
		849	if (forced \|\| pen == m_barSets.at(i)->pen()) {
		850	QColor c = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0);
		851	m_barSets.at(i)->setPen(c);
		852	}
		853	}
		854	}
		855
809	#include "moc_qabstractbarseries.cpp"	856	#include "moc_qabstractbarseries.cpp"
810	#include "moc_qabstractbarseries_p.cpp"	857	#include "moc_qabstractbarseries_p.cpp"
811		858

src/barchart/qabstractbarseries_p.h +6 -4

                 void setVisible(bool visible);
                 void setLabelsVisible(bool visible);
-                void scaleDomain(Domain &domain);
+                void initializeDomain();
-                ChartElement *createGraphics(ChartPresenter *presenter);
+                void initializeAxes();
-                QList<QLegendMarker*> createLegendMarkers(QLegend* legend);
+                void initializeTheme(int index, ChartTheme* theme, bool forced = false);
+                QList<QLegendMarker*> createLegendMarkers(QLegend *legend);
-                void initializeAxis(QAbstractAxis *axis);
                 virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const;
+                QAbstractAxis* createDefaultAxis(Qt::Orientation orientation) const;
                 bool append(QBarSet *set);
                 bool remove(QBarSet *set);

src/barchart/vertical/bar/barchartitem.cpp +2 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            BarChartItem::BarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
+            BarChartItem::BarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
-                AbstractBarChartItem(series, presenter)
+                AbstractBarChartItem(series, item)
             {
             }

src/barchart/vertical/bar/barchartitem_p.h +1 -1

             {
                 Q_OBJECT
             public:
-                BarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
+                BarChartItem(QAbstractBarSeries *series, QGraphicsItem* item = 0);
             private:
                 virtual QVector<QRectF> calculateLayout();

src/barchart/vertical/bar/qbarseries.cpp +22 -13

             QBarSeries::~QBarSeries()
             {
                 Q_D(QBarSeries);
-                if (d->m_dataset)
+                if (d->m_chart)
-                    d->m_dataset->removeSeries(this);
+                    d->m_chart->removeSeries(this);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             }
-            void QBarSeriesPrivate::scaleDomain(Domain &domain)
+            void QBarSeriesPrivate::initializeDomain()
             {
-                qreal minX(domain.minX());
+                qreal minX(domain()->minX());
-                qreal minY(domain.minY());
+                qreal minY(domain()->minY());
-                qreal maxX(domain.maxX());
+                qreal maxX(domain()->maxX());
-                qreal maxY(domain.maxY());
+                qreal maxY(domain()->maxY());
                 qreal x = categoryCount();
                 minX = qMin(minX, - (qreal)0.5);
                 maxX = qMax(maxX, x - (qreal)0.5);
                 maxY = qMax(maxY, max());
-                domain.setRange(minX, maxX, minY, maxY);
+                domain()->setRange(minX, maxX, minY, maxY);
             }
-            ChartElement *QBarSeriesPrivate::createGraphics(ChartPresenter *presenter)
+            void QBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QBarSeries);
+                BarChartItem *bar = new BarChartItem(q,parent);
+                m_item.reset(bar);
+                QAbstractSeriesPrivate::initializeGraphics(parent);
+            }
-                BarChartItem *bar = new BarChartItem(q, presenter);
+            void QBarSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
-                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
+                BarChartItem *bar = static_cast<BarChartItem *>(m_item.data());
+                Q_ASSERT(bar);
+                if (options.testFlag(QChart::SeriesAnimations)) {
                     bar->setAnimation(new BarAnimation(bar));
-                presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
+                }else{
-                return bar;
+                    bar->setAnimation(0);
+                }
+                QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qbarseries.cpp"

src/barchart/vertical/bar/qbarseries_p.h +4 -2

             {
             public:
                 QBarSeriesPrivate(QBarSeries *q);
-                ChartElement *createGraphics(ChartPresenter *presenter);
+                void initializeGraphics(QGraphicsItem* parent);
-                void scaleDomain(Domain &domain);
+                void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
+                void initializeDomain();
             private:
                 Q_DECLARE_PUBLIC(QBarSeries)
             };

src/barchart/vertical/percent/percentbarchartitem.cpp +2 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            PercentBarChartItem::PercentBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
+            PercentBarChartItem::PercentBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
-                AbstractBarChartItem(series, presenter)
+                AbstractBarChartItem(series, item)
             {
             }

src/barchart/vertical/percent/percentbarchartitem_p.h +1 -1

             {
                 Q_OBJECT
             public:
-                PercentBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
+                PercentBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item = 0);
             private:
                 virtual QVector<QRectF> calculateLayout();

src/barchart/vertical/percent/qpercentbarseries.cpp +22 -14

             QPercentBarSeries::~QPercentBarSeries()
             {
                 Q_D(QPercentBarSeries);
-                if (d->m_dataset)
+                if (d->m_chart)
-                    d->m_dataset->removeSeries(this);
+                    d->m_chart->removeSeries(this);
             }
             /*!
             }
-            void QPercentBarSeriesPrivate::scaleDomain(Domain &domain)
+            void QPercentBarSeriesPrivate::initializeDomain()
             {
-                qreal minX(domain.minX());
+                qreal minX(domain()->minX());
-                qreal minY(domain.minY());
+                qreal minY(domain()->minY());
-                qreal maxX(domain.maxX());
+                qreal maxX(domain()->maxX());
-                qreal maxY(domain.maxY());
+                qreal maxY(domain()->maxY());
                 qreal x = categoryCount();
                 minX = qMin(minX, - (qreal)0.5);
                 minY = 0;
                 maxY = 100;
-                domain.setRange(minX, maxX, minY, maxY);
+                domain()->setRange(minX, maxX, minY, maxY);
             }
-            ChartElement *QPercentBarSeriesPrivate::createGraphics(ChartPresenter *presenter)
+            void QPercentBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QPercentBarSeries);
+                PercentBarChartItem *bar = new PercentBarChartItem(q,parent);
+                m_item.reset(bar);
+                QAbstractSeriesPrivate::initializeGraphics(parent);
+            }
-                PercentBarChartItem *bar = new PercentBarChartItem(q, presenter);
+            void QPercentBarSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
-                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
+                PercentBarChartItem *bar = static_cast<PercentBarChartItem *>(m_item.data());
+                Q_ASSERT(bar);
+                if (options.testFlag(QChart::SeriesAnimations)) {
                     bar->setAnimation(new PercentBarAnimation(bar));
-                presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
+                }else{
-                return bar;
+                    bar->setAnimation(0);
+                }
+                QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qpercentbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/percent/qpercentbarseries_p.h +3 -2

             {
             public:
                 QPercentBarSeriesPrivate(QPercentBarSeries *q);
-                void scaleDomain(Domain &domain);
+                void initializeDomain();
-                ChartElement *createGraphics(ChartPresenter *presenter);
+                void initializeGraphics(QGraphicsItem* parent);
+                void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
             private:
                 Q_DECLARE_PUBLIC(QPercentBarSeries)
             };

src/barchart/vertical/stacked/qstackedbarseries.cpp +22 -14

             QStackedBarSeries::~QStackedBarSeries()
             {
                 Q_D(QStackedBarSeries);
-                if (d->m_dataset)
+                if (d->m_chart)
-                    d->m_dataset->removeSeries(this);
+                    d->m_chart->removeSeries(this);
             }
             /*!
                 Returns QChartSeries::SeriesTypeStackedBar.
             }
-            void QStackedBarSeriesPrivate::scaleDomain(Domain &domain)
+            void QStackedBarSeriesPrivate::initializeDomain()
             {
-                qreal minX(domain.minX());
+                qreal minX(domain()->minX());
-                qreal minY(domain.minY());
+                qreal minY(domain()->minY());
-                qreal maxX(domain.maxX());
+                qreal maxX(domain()->maxX());
-                qreal maxY(domain.maxY());
+                qreal maxY(domain()->maxY());
                 qreal x = categoryCount();
                 minX = qMin(minX, - (qreal)0.5);
                 maxX = qMax(maxX, x - (qreal)0.5);
                 maxY = qMax(maxY, top());
-                domain.setRange(minX, maxX, minY, maxY);
+                domain()->setRange(minX, maxX, minY, maxY);
             }
-            ChartElement *QStackedBarSeriesPrivate::createGraphics(ChartPresenter *presenter)
+            void QStackedBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QStackedBarSeries);
+                StackedBarChartItem *bar = new StackedBarChartItem(q,parent);
+                m_item.reset(bar);
+                QAbstractSeriesPrivate::initializeGraphics(parent);
+            }
-                StackedBarChartItem *bar = new StackedBarChartItem(q, presenter);
+            void QStackedBarSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
-                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
+                StackedBarChartItem *bar = static_cast<StackedBarChartItem *>(m_item.data());
+                Q_ASSERT(bar);
+                if (options.testFlag(QChart::SeriesAnimations)) {
                     bar->setAnimation(new StackedBarAnimation(bar));
-                presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
+                }else{
-                return bar;
+                    bar->setAnimation(0);
+                }
+                QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qstackedbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/stacked/qstackedbarseries_p.h +3 -2

             {
             public:
                 QStackedBarSeriesPrivate(QStackedBarSeries *q);
-                ChartElement *createGraphics(ChartPresenter *presenter);
+                void initializeGraphics(QGraphicsItem* parent);
-                void scaleDomain(Domain &domain);
+                void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
+                void initializeDomain();
             private:
                 Q_DECLARE_PUBLIC(QStackedBarSeries)
             };

src/barchart/vertical/stacked/stackedbarchartitem.cpp +2 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            StackedBarChartItem::StackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
+            StackedBarChartItem::StackedBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
-                AbstractBarChartItem(series, presenter)
+                AbstractBarChartItem(series, item)
             {
             }

src/barchart/vertical/stacked/stackedbarchartitem_p.h +1 -1

             {
                 Q_OBJECT
             public:
-                StackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
+                StackedBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item =0);
             private:
                 virtual QVector<QRectF> calculateLayout();

src/chartdataset.cpp +242 -331

This diff has been collapsed as it changes many lines, (573 lines changed) Show them Hide them
	@@ -19,7 +19,9
	19	****************************************************************************/	19	****************************************************************************/
	20		20
	21	#include "chartdataset_p.h"	21	#include "chartdataset_p.h"
			22	#include "chartpresenter_p.h"
	22	#include "qchart.h"	23	#include "qchart.h"
			24	#include "qchart_p.h"
	23	#include "qvalueaxis.h"	25	#include "qvalueaxis.h"
	24	#include "qbarcategoryaxis.h"	26	#include "qbarcategoryaxis.h"
	25	#include "qvalueaxis_p.h"	27	#include "qvalueaxis_p.h"
	@@ -29,6 +31,7
	29	#include "qstackedbarseries.h"	31	#include "qstackedbarseries.h"
	30	#include "qpercentbarseries.h"	32	#include "qpercentbarseries.h"
	31	#include "qpieseries.h"	33	#include "qpieseries.h"
			34	#include "chartitem_p.h"
	32		35
	33	#ifndef QT_ON_ARM	36	#ifndef QT_ON_ARM
	34	#include "qdatetimeaxis.h"	37	#include "qdatetimeaxis.h"
	@@ -36,8 +39,9
	36		39
	37	QTCOMMERCIALCHART_BEGIN_NAMESPACE	40	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	38		41
	39	ChartDataSet::ChartDataSet(QChart *~~paren~~t)	42	ChartDataSet::ChartDataSet(QChart *chart)
	40	: QObject(~~paren~~t)	43	: QObject(chart),
			44	m_chart(chart)
	41	{	45	{
	42		46
	43	}	47	}
	@@ -45,451 +49,358 ChartDataSet::ChartDataSet(QChart *parent)
	45	ChartDataSet::~ChartDataSet()	49	ChartDataSet::~ChartDataSet()
	46	{	50	{
	47	removeAllSeries();	51	removeAllSeries();
			52	removeAllAxes();
	48	}	53	}
	49		54
			55	/*
			56	* This method adds series to chartdataset, series ownership is taken from caller.
			57	*/
	50	void ChartDataSet::addSeries(QAbstractSeries *series)	58	void ChartDataSet::addSeries(QAbstractSeries *series)
	51	{	59	{
	52	Domain *domain = m_seriesDomainMap.value(series);	60	if (m_seriesList.contains(series)) {
			61	qWarning() << QObject::tr("Can not add series. Series already on the chart.");
			62	return;
			63	}
			64
			65	series->d_ptr->initializeDomain();
			66	m_seriesList.append(series);
			67
			68	series->setParent(this); // take ownership
			69	series->d_ptr->m_chart = m_chart;
			70
			71	emit seriesAdded(series);
			72	}
	53		73
	54	if (domain) {	74	/*
	55	qWarning() << "Can not add series. Series already on the chart";	75	* This method adds axis to chartdataset, axis ownership is taken from caller.
			76	*/
			77	void ChartDataSet::addAxis(QAbstractAxis *axis,Qt::Alignment aligment)
			78	{
			79	if (m_axisList.contains(axis)) {
			80	qWarning() << QObject::tr("Can not add axis. Axis already on the chart.");
	56	return;	81	return;
	57	}	82	}
	58		83
	59	domain = new Domain(series);	84	axis->d_ptr->setAlignment(aligment);
	60	m_seriesDomainMap.insert(series, domain);
	61	series->d_ptr->scaleDomain(*domain);
	62		85
	63	createSeriesIndex(series);	86	if(!axis->alignment()) {
			87	qWarning()<< QObject::tr("No alignment specified !");
			88	return;
			89	};
	64		90
	65	series->setParent(this); // take ownership	91	QSharedPointer<Domain> domain(new Domain());
	66	series->d_ptr->m_chart = qobject_cast<QChart *>(parent());	92	axis->d_ptr->initializeDomain(domain.data());
	67	series->d_ptr->m_dataset = this;
	68		93
	69	emit seriesAdded(series, domain);	94	axis->setParent(this);
			95	axis->d_ptr->m_chart = m_chart;
			96	m_axisList.append(axis);
	70		97
			98	emit axisAdded(axis);
	71	}	99	}
	72		100
			101	/*
			102	* This method removes series form chartdataset, series ownership is passed back to caller.
			103	*/
	73	void ChartDataSet::removeSeries(QAbstractSeries *series)	104	void ChartDataSet::removeSeries(QAbstractSeries *series)
	74	{	105	{
	75		106
	76	if (!m_series~~DomainMap~~.contains(series)) {	107	if (! m_seriesList.contains(series)) {
	77	qWarning() << "Can not remove series. Series not found on the chart.";	108	qWarning() << QObject::tr("Can not remove series. Series not found on the chart.");
	78	return;	109	return;
	79	}	110	}
	80		111
	81	emit seriesRemoved(series);	112	emit seriesRemoved(series);
	82		113	m_seriesList.removeAll(series);
	83	Domain *domain = m_seriesDomainMap.take(series);
	84	delete domain;
	85	domain = 0;
	86
	87	removeSeriesIndex(series);
	88		114
	89	series->setParent(0);	115	series->setParent(0);
	90	series->d_ptr->m_chart = 0;	116	series->d_ptr->m_chart = 0;
	91	series->d_ptr->m_d~~ataset~~ = 0;	117	series->d_ptr->m_domain.clear();
	92
	93	removeAxes(series);
	94	}
	95
	96		118
			119	QList<QAbstractAxis*> axes = series->d_ptr->m_axes;
	97		120
	98	void ChartDataSet::createSeriesIndex(QAbstractSeries *series)	121	foreach(QAbstractAxis* axis, axes) {
	99	{	122	axis->d_ptr->m_series.removeAll(series);
	100	QMapIterator<int, QAbstractSeries *> i(m_indexSeriesMap);	123	series->d_ptr->m_axes.removeAll(axis);
	101
	102	int key = 0;
	103	while (i.hasNext()) {
	104	i.next();
	105	if (i.key() != key)
	106	break;
	107	key++;
	108	}	124	}
	109
	110	m_indexSeriesMap.insert(key, series);
	111	}	125	}
	112		126
	113	void ChartDataSet::removeSeriesIndex(QAbstractSeries *series)	127	/*
	114	{	128	* This method removes axis form chartdataset, series ownership is passed back to caller.
	115	int key = seriesIndex(series);	129	*/
	116	Q_ASSERT(key != -1);	130	void ChartDataSet::removeAxis(QAbstractAxis *axis)
	117	m_indexSeriesMap.remove(key);
	118	}
	119
	120	void ChartDataSet::createDefaultAxes()
	121	{	131	{
	122	if (m_seriesDomainMap.isEmpty())	132	if (! m_axisList.contains(axis)) {
			133	qWarning() << QObject::tr("Can not remove axis. Axis not found on the chart.");
	123	return;	134	return;
	124
	125	QAbstractAxis::AxisTypes typeX(0);
	126	QAbstractAxis::AxisTypes typeY(0);
	127
	128	// Remove possibly existing axes
	129	QMapIterator<QAbstractSeries , Domain > i(m_seriesDomainMap);
	130	while (i.hasNext()) {
	131	i.next();
	132	removeAxes(i.key());
	133	}	135	}
	134		136
	135	i.toFront();	137	emit axisRemoved(axis);
			138	m_axisList.removeAll(axis);
	136		139
	137	// Select the required axis x and axis y types based on the types of the current series	140	axis->setParent(0);
	138	while (i.hasNext()) {	141	axis->d_ptr->m_chart = 0;
	139	i.next();
	140	QAbstractAxis *axisX = m_seriesAxisXMap.value(i.key());
	141	QAbstractAxis *axisY = m_seriesAxisYMap.value(i.key());
	142	if (axisX)
	143	typeX &= axisX->type();
	144	else
	145	typeX \|= i.key()->d_ptr->defaultAxisType(Qt::Horizontal);
	146	if (axisY)
	147	typeY &= axisY->type();
	148	else
	149	typeY \|= i.key()->d_ptr->defaultAxisType(Qt::Vertical);
	150	}
	151		142
	152	// Create the axes of the types selected	143	QList<QAbstractSeries*> series = axis->d_ptr->m_series;
	153	createAxes(typeX, Qt::Horizontal);
	154	createAxes(typeY, Qt::Vertical);
	155	}
	156		144
	157	void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation)	145	foreach(QAbstractSeries* s, series) {
	158	{	146	s->d_ptr->m_axes.removeAll(axis);
	159	QMapIterator<QAbstractSeries , Domain > i(m_seriesDomainMap);	147	axis->d_ptr->m_series.removeAll(s);
	160
	161	// TODO: Add a descriptive comment of what happens here
	162	if (type.testFlag(QAbstractAxis::AxisTypeValue) && type.testFlag(QAbstractAxis::AxisTypeBarCategory)) {
	163	while (i.hasNext()) {
	164	i.next();
	165	QAbstractAxis *axis = createAxis(i.key()->d_ptr->defaultAxisType(orientation), orientation);
	166	if (axis) {
	167	initializeAxis(axis, i.key());
	168	emit axisAdded(axis, i.value());
	169	}
	170	}
	171	} else if (!type.testFlag(QAbstractAxis::AxisTypeNoAxis)) {
	172	QAbstractAxis *axis = createAxis(QAbstractAxis::AxisType(int(type)), orientation);
	173	i.toFront();
	174	while (i.hasNext()) {
	175	i.next();
	176	initializeAxis(axis, i.key());
	177	}
	178	emit axisAdded(axis, i.value());
	179	}	148	}
	180	}	149	}
	181		150
	182	QAbstractAxis *ChartDataSet::createAxis(QAbstractAxis::AxisType type, Qt::Orientation orientation)	151	/*
			152	* This method attach axis to series, return true if success.
			153	*/
			154	bool ChartDataSet::attachAxis(QAbstractSeries* series,QAbstractAxis *axis)
	183	{	155	{
	184	QAbstractAxis *axis = 0;	156	Q_ASSERT(series);
			157	Q_ASSERT(axis);
	185		158
	186	switch (type) {	159	QList<QAbstractSeries* > attachedSeriesList = axis->d_ptr->m_series;
	187	case QAbstractAxis::AxisTypeValue:	160	QList<QAbstractAxis* > attachedAxisList = series->d_ptr->m_axes;
	188	axis = new QValueAxis(this);	161	QSharedPointer<Domain> domain = series->d_ptr->m_domain;
	189	break;
	190	case QAbstractAxis::AxisTypeBarCategory:
	191	axis = new QBarCategoryAxis(this);
	192	break;
	193	case QAbstractAxis::AxisTypeCategory:
	194	axis = new QCategoryAxis(this);
	195	break;
	196	#ifndef Q_WS_QWS
	197	case QAbstractAxis::AxisTypeDateTime:
	198	axis = new QDateTimeAxis(this);
	199	break;
	200	#endif
	201	default:
	202	axis = 0;
	203	break;
	204	}
	205		162
	206	if (axis)	163	if (!m_seriesList.contains(series)) {
	207	axis->d_ptr->setOrientation(orientation);	164	qWarning() << QObject::tr("Can not find series on the chart.");
			165	return false;
			166	}
	208		167
	209	return axis;	168	if (axis && !m_axisList.contains(axis)) {
	210	}	169	qWarning() << QObject::tr("Can not find axis on the chart.");
			170	return false;
			171	}
	211		172
	212	void ChartDataSet::initializeAxis(QAbstractAxis axis, QAbstractSeries series)	173	if (attachedAxisList.contains(axis)) {
	213	{	174	qWarning() << QObject::tr("Axis already attached to series.");
	214	Domain *domain = m_seriesDomainMap.value(series);	175	return false;
	215	axis->d_ptr->m_dataset = this;
	216	series->d_ptr->initializeAxis(axis);
	217	axis->d_ptr->intializeDomain(domain);
	218	if (axis->orientation() == Qt::Horizontal) {
	219	QObject::connect(axis->d_ptr.data(), SIGNAL(updated()), domain, SLOT(handleAxisUpdated()));
	220	QObject::connect(domain, SIGNAL(updated()), axis->d_ptr.data(), SLOT(handleDomainUpdated()));
	221	m_seriesAxisXMap.insert(series, axis);
	222	} else {
	223	QObject::connect(axis->d_ptr.data(), SIGNAL(updated()), domain, SLOT(handleAxisUpdated()));
	224	QObject::connect(domain, SIGNAL(updated()), axis->d_ptr.data(), SLOT(handleDomainUpdated()));
	225	m_seriesAxisYMap.insert(series, axis);
	226	}	176	}
	227	axis->d_ptr->emitUpdated();
	228	}
	229		177
	230	void ChartDataSet::removeAxes(QAbstractSeries *series)	178	Q_ASSERT(!attachedSeriesList.contains(series));
	231	{	179	Q_ASSERT(!domain.isNull());
	232	QAbstractAxis *axisX = m_seriesAxisXMap.take(series);
	233		180
	234	if (axisX) {	181	if(attachedSeriesList.isEmpty()){
	235	QList<QAbstractAxis *> axesX = m_seriesAxisXMap.values();
	236	int x = axesX.indexOf(axisX);
	237		182
	238	if (x == -1) {	183	}else{
	239	emit axisRemoved(axisX);	184	domain = attachedSeriesList.first()->d_ptr->domain();
	240	axisX->d_ptr->m_dataset = 0;	185	Q_ASSERT(!domain.isNull());
	241	axisX->deleteLater();	186	series->d_ptr->setDomain(domain);
	242	}
	243	}	187	}
	244		188
	245	QAbstractAxis *axisY = m_seriesAxisYMap.take(series);	189	series->d_ptr->m_axes<<axis;
			190	axis->d_ptr->m_series<<series;
	246		191
	247	if (axisY) {	192	series->d_ptr->initializeAxes();
	248	QList<QAbstractAxis *> axesY = m_seriesAxisYMap.values();	193	axis->d_ptr->initializeDomain(domain.data());
	249		194
	250	int y = axesY.indexOf(axisY);	195	if(axis->orientation()==Qt::Vertical){
			196	QObject::connect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), domain.data(), SLOT(handleVerticalAxisRangeChanged(qreal,qreal)));
			197	QObject::connect(domain.data(), SIGNAL(rangeVerticalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
			198	}
	251		199
	252	if (y == -1) {	200	if(axis->orientation()==Qt::Horizontal){
	253	emit axisRemoved(axisY);	201	QObject::connect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), domain.data(), SLOT(handleHorizontalAxisRangeChanged(qreal,qreal)));
	254	axisY->d_ptr->m_dataset = 0;	202	QObject::connect(domain.data(), SIGNAL(rangeHorizontalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
	255	axisY->deleteLater();
	256	}
	257	}	203	}
			204
			205	return true;
	258	}	206	}
	259		207
	260	void ChartDataSet::removeAxis(QAbstractAxis *axis)	208	/*
			209	* This method detach axis to series, return true if success.
			210	*/
			211	bool ChartDataSet::detachAxis(QAbstractSeries* series,QAbstractAxis *axis)
	261	{	212	{
	262	if (!axis->d_ptr->m_dataset) {	213	Q_ASSERT(series);
	263	qWarning() << "UnBound axis found !";	214	Q_ASSERT(axis);
	264	return;
	265	}
	266		215
	267	QMap<QAbstractSeries , QAbstractAxis > *seriesAxisMap;	216	QList<QAbstractSeries* > attachedSeriesList = axis->d_ptr->m_series;
			217	QList<QAbstractAxis* > attachedAxisList = series->d_ptr->m_axes;
			218	QSharedPointer<Domain> domain = series->d_ptr->m_domain;
	268		219
	269	if (axis->orientation() == Qt::Vertical)	220	if (!m_seriesList.contains(series)) {
	270	seriesAxisMap = &m_seriesAxisYMap;	221	qWarning() << QObject::tr("Can not find series on the chart.");
	271	else	222	return false;
	272	seriesAxisMap = &m_seriesAxisXMap;	223	}
	273		224
	274	QMapIterator<QAbstractSeries , QAbstractAxis > i(*seriesAxisMap);	225	if (axis && !m_axisList.contains(axis)) {
			226	qWarning() << QObject::tr("Can not find axis on the chart.");
			227	return false;
			228	}
	275		229
	276	while (i.hasNext()) {	230	if (!attachedAxisList.contains(axis)) {
	277	i.next();	231	qWarning() << QObject::tr("Axis not attached to series.");
	278	if (i.value() == axis)	232	return false;
	279	removeSeries(i.key());
	280	}	233	}
	281	}
	282		234
	283	void ChartDataSet::removeAllSeries()	235	Q_ASSERT(axis->d_ptr->m_series.contains(series));
	284	{	236
	285	QList<QAbstractSeries *> series = m_seriesDomainMap.keys();	237	series->d_ptr->m_axes.removeAll(axis);
	286	foreach (QAbstractSeries *s , series)	238	axis->d_ptr->m_series.removeAll(series);
	287	removeSeries(s);
	288		239
	289	Q_ASSERT(m_seriesAxisXMap.count() == 0);	240	if(axis->orientation()==Qt::Vertical){
	290	Q_ASSERT(m_seriesAxisXMap.count() == 0);	241	QObject::disconnect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), domain.data(), SLOT(handleVerticalAxisRangeChanged(qreal,qreal)));
	291	Q_ASSERT(m_seriesDomainMap.count() == 0);	242	QObject::disconnect(domain.data(), SIGNAL(rangeVerticalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
			243	}
			244
			245	if(axis->orientation()==Qt::Horizontal){
			246	QObject::disconnect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), domain.data(), SLOT(handleHorizontalAxisRangeChanged(qreal,qreal)));
			247	QObject::disconnect(domain.data(), SIGNAL(rangeHorizontalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
			248	}
	292		249
	293	qDeleteAll(series);	250	return true;
	294	}	251	}
	295		252
	296	void ChartDataSet::zoomInDomain(const QRectF &rect, const QSizeF &size)	253	void ChartDataSet::createDefaultAxes()
	297	{	254	{
	298	//for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates	255	if (m_seriesList.isEmpty())
			256	return;
	299		257
			258	QAbstractAxis::AxisTypes typeX(0);
			259	QAbstractAxis::AxisTypes typeY(0);
	300		260
	301	blockAxisSignals(true);	261	// Remove possibly existing axes
			262	removeAllAxes();
	302		263
	303	QMapIterator<QAbstractSeries , Domain > i(m_seriesDomainMap);	264	Q_ASSERT(m_axisList.isEmpty());
	304		265
	305	while (i.hasNext()) {	266	// Select the required axis x and axis y types based on the types of the current series
	306	i.next();	267	foreach(QAbstractSeries* s, m_seriesList) {
	307	i.value()->zoomIn(rect, size);	268	typeX \|= s->d_ptr->defaultAxisType(Qt::Horizontal);
			269	typeY \|= s->d_ptr->defaultAxisType(Qt::Vertical);
	308	}	270	}
	309		271
	310	blockAxisSignals(false);	272	// Create the axes of the types selected
			273	createAxes(typeX, Qt::Horizontal);
			274	createAxes(typeY, Qt::Vertical);
	311		275
	312	}	276	}
	313		277
	314	void ChartDataSet::zoomOutDomain(const QRectF &rect, const QSizeF &size)	278	void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation)
	315	{	279	{
	316	//for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates	280	QAbstractAxis *axis = 0;
	317		281	//decide what axis should be created
	318	blockAxisSignals(true);
	319
	320	QMapIterator<QAbstractSeries , Domain > i(m_seriesDomainMap);
	321		282
	322	while (i.hasNext()) {	283	switch (type) {
	323	i.next();	284	case QAbstractAxis::AxisTypeValue:
	324	i.value()->zoomOut(rect, size);	285	axis = new QValueAxis(this);
			286	break;
			287	case QAbstractAxis::AxisTypeBarCategory:
			288	axis = new QBarCategoryAxis(this);
			289	break;
			290	case QAbstractAxis::AxisTypeCategory:
			291	axis = new QCategoryAxis(this);
			292	break;
			293	#ifndef Q_WS_QWS
			294	case QAbstractAxis::AxisTypeDateTime:
			295	axis = new QDateTimeAxis(this);
			296	break;
			297	#endif
			298	default:
			299	axis = 0;
			300	break;
	325	}	301	}
	326		302
	327	blockAxisSignals(false);	303	if (axis) {
	328	}	304	//create one axis for all
	329		305
	330	void ChartDataSet::blockAxisSignals(bool enabled)	306	addAxis(axis,orientation==Qt::Horizontal?Qt::AlignBottom:Qt::AlignLeft);
	331	{	307
	332	QMapIterator<QAbstractSeries , Domain > i(m_seriesDomainMap);	308	foreach(QAbstractSeries *s, m_seriesList) {
	333	while (i.hasNext()) {	309	attachAxis(s,axis);
	334	i.next();
	335	QAbstractAxis *axisX = m_seriesAxisXMap.value(i.key());
	336	QAbstractAxis *axisY = m_seriesAxisYMap.value(i.key());
	337	if (axisX) {
	338	axisX->d_ptr->blockSignals(enabled);
	339	if (!enabled) {
	340	axisX->d_ptr->setDirty(false);
	341	axisX->d_ptr->emitUpdated();
	342	}
	343	}
	344	if (axisY) {
	345	axisY->d_ptr->blockSignals(enabled);
	346	if (!enabled) {
	347	axisY->d_ptr->setDirty(false);
	348	axisY->d_ptr->emitUpdated();
	349	}
	350	}	310	}
	351	}
	352	}
	353		311
	354	int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type)
	355	{
	356	int count = 0;
	357	QMapIterator<QAbstractSeries , Domain > i(m_seriesDomainMap);
	358	while (i.hasNext()) {
	359	i.next();
	360	if (i.key()->type() == type)
	361	count++;
	362	}	312	}
	363	return count;	313	else if (!type.testFlag(QAbstractAxis::AxisTypeNoAxis)) {
	364	}	314	//create separate axis
	365		315	foreach(QAbstractSeries *s, m_seriesList) {
	366	int ChartDataSet::seriesIndex(QAbstractSeries *series)	316	QAbstractAxis *axis = s->d_ptr->createDefaultAxis(orientation);
	367	{	317	if(axis) {
	368	QMapIterator<int, QAbstractSeries *> i(m_indexSeriesMap);	318	addAxis(axis,orientation==Qt::Horizontal?Qt::AlignBottom:Qt::AlignLeft);
	369	while (i.hasNext()) {	319	attachAxis(s,axis);
	370	i.next();	320	}
	371	if (i.value() == series)	321	}
	372	return i.key();
	373	}	322	}
	374	return -1;
	375	}	323	}
	376		324
	377	QAbstractAxis ChartDataSet::axisX(QAbstractSeries series) const	325	void ChartDataSet::removeAllSeries()
	378	{	326	{
	379	if (series == 0) {	327	foreach (QAbstractSeries *s , m_seriesList)
	380		328	removeSeries(s);
	381	QMapIterator<QAbstractSeries , QAbstractAxis > i(m_seriesAxisXMap);
	382		329
	383	while (i.hasNext()) {	330	Q_ASSERT(m_seriesList.count() == 0);
	384	i.next();	331	qDeleteAll(m_seriesList);
	385	if (i.value()->isVisible())
	386	return i.value();
	387	}
	388	return 0;
	389	}
	390	return m_seriesAxisXMap.value(series);
	391	}	332	}
	392		333
	393	QAbstractAxis ChartDataSet::axisY(QAbstractSeries series) const	334	void ChartDataSet::removeAllAxes()
	394	{	335	{
	395	if (series == 0) {	336	foreach (QAbstractAxis *a , m_axisList)
	396	QMapIterator<QAbstractSeries , QAbstractAxis > i(m_seriesAxisYMap);	337	removeAxis(a);
	397		338
	398	while (i.hasNext()) {	339	Q_ASSERT(m_axisList.count() == 0);
	399	i.next();	340	qDeleteAll(m_axisList);
	400	if (i.value()->isVisible()) return i.value();
	401	}
	402	return 0;
	403	}
	404	return m_seriesAxisYMap.value(series);
	405	}	341	}
	406		342
	407	void ChartDataSet::setAxis(QAbstractSeries series, QAbstractAxis axis, Qt::Orientation orientation)	343	void ChartDataSet::zoomInDomain(const QRectF &rect)
	408	{	344	{
	409	Q_ASSERT(axis);	345	QList<Domain*> domains;
	410		346	foreach(QAbstractSeries *s, m_seriesList) {
	411	if (!series) {	347	Domain* domain = s->d_ptr->m_domain.data();
	412	qWarning() << "Series not found on the chart.";	348	if(domains.contains(domain)) continue;
	413	return;	349	s->d_ptr->m_domain->blockAxisSignals(true);
			350	domains<<domain;
	414	}	351	}
	415		352
	416	Domain *domain = m_seriesDomainMap.value(series);	353	foreach(Domain *domain, domains)
			354	domain->zoomIn(rect);
	417		355
	418	if (!domain) {	356	foreach(Domain *domain, domains)
	419	qWarning() << "Series not found on the chart.";	357	domain->blockAxisSignals(false);
	420	return;	358	}
	421	}
	422
	423	if (orientation == Qt::Horizontal && axis->orientation() == Qt::Vertical) {
	424	qWarning() << "Axis already defined as axis Y";
	425	return;
	426	}
	427		359
	428	if (orientation == Qt::Vertical && axis->orientation() == Qt::Horizontal) {	360	void ChartDataSet::zoomOutDomain(const QRectF &rect)
	429	qWarning() << "Axis already defined as axis X";	361	{
	430	return;	362	QList<Domain*> domains;
			363	foreach(QAbstractSeries *s, m_seriesList) {
			364	Domain* domain = s->d_ptr->m_domain.data();
			365	if(domains.contains(domain)) continue;
			366	s->d_ptr->m_domain->blockAxisSignals(true);
			367	domains<<domain;
	431	}	368	}
	432		369
	433	axis->d_ptr->setOrientation(orientation);	370	foreach(Domain *domain, domains)
	434		371	domain->zoomOut(rect);
	435	QMap<QAbstractSeries , QAbstractAxis > *seriesAxisMap;
	436		372
	437	if (orientation == Qt::Vertical)	373	foreach(Domain *domain, domains)
	438	seriesAxisMap = &m_seriesAxisYMap;	374	domain->blockAxisSignals(false);
	439	else	375	}
	440	seriesAxisMap = &m_seriesAxisXMap;
	441
	442	if (seriesAxisMap->value(series) == axis) {
	443	qWarning() << "The axis already set for the series";
	444	return;
	445	}
	446		376
	447	QAbstractAxis *oldAxis = seriesAxisMap->take(series);	377	void ChartDataSet::scrollDomain(qreal dx, qreal dy)
	448	QList<QAbstractAxis *> axes = seriesAxisMap->values();	378	{
	449	if (oldAxis) {	379	QList<Domain*> domains;
	450	if (axes.indexOf(oldAxis) == -1) {	380	foreach(QAbstractSeries *s, m_seriesList) {
	451	emit axisRemoved(oldAxis);	381	Domain* domain = s->d_ptr->m_domain.data();
	452	oldAxis->disconnect();	382	if(domains.contains(domain)) continue;
	453	QObject::disconnect(domain, 0, oldAxis, 0);	383	s->d_ptr->m_domain->blockAxisSignals(true);
	454	oldAxis->d_ptr->m_dataset = 0;	384	domains<<domain;
	455	oldAxis->deleteLater();
	456	}
	457	}	385	}
	458		386
	459	if (axes.indexOf(axis) == -1) {	387	foreach(Domain *domain, domains)
	460	initializeAxis(axis, series);	388	domain->move(dx, dy);
	461	emit axisAdded(axis, domain);
	462	} else {
	463	initializeAxis(axis, series);
	464	}
	465	}
	466		389
	467	Domain ChartDataSet::domain(QAbstractSeries series) const	390	foreach(Domain *domain, domains)
	468	{	391	domain->blockAxisSignals(false);
	469	return m_seriesDomainMap.value(series);
	470	}	392	}
	471		393
	472	void ChartDataSet::scrollDomain(qreal dx, qreal dy, const QSizeF &size)	394	QList<QAbstractAxis*> ChartDataSet::axes() const
	473	{	395	{
	474	blockAxisSignals(true);	396	return m_axisList;
	475	QMapIterator<QAbstractSeries , Domain > i(m_seriesDomainMap);
	476	while (i.hasNext()) {
	477	i.next();
	478	i.value()->move(dx, dy, size);
	479	}
	480	blockAxisSignals(false);
	481	}	397	}
	482		398
	483	QList<QAbstractSeries *> ChartDataSet::series() const	399	QList<QAbstractSeries *> ChartDataSet::series() const
	484	{	400	{
	485	return m_series~~DomainMap~~.~~keys~~();	401	return m_seriesList;
	486	}	402	}
	487	/*	403
	488	void ChartDataSet::updateSeries(QAbstractSeries *series)
	489	{
	490	emit seriesUpdated(series);
	491	}
	492	*/
	493	#include "moc_chartdataset_p.cpp"	404	#include "moc_chartdataset_p.cpp"
	494		405
	495	QTCOMMERCIALCHART_END_NAMESPACE	406	QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset_p.h +20 -31

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxis;
+            class ChartPresenter;
             class QTCOMMERCIALCHART_AUTOTEST_EXPORT ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
-                ChartDataSet(QChart *parent = 0);
+                ChartDataSet(QChart *chart);
                 virtual ~ChartDataSet();
                 void addSeries(QAbstractSeries *series);
                 void removeSeries(QAbstractSeries *series);
+                QList<QAbstractSeries *> series() const;
                 void removeAllSeries();
-            //    void updateSeries(QAbstractSeries* series);
-                void zoomInDomain(const QRectF &rect, const QSizeF &size);
-                void zoomOutDomain(const QRectF &rect, const QSizeF &size);
-                void scrollDomain(qreal dx, qreal dy, const QSizeF &size);
-                int seriesCount(QAbstractSeries::SeriesType type);
-                int seriesIndex(QAbstractSeries *series);
-                QAbstractAxis *axisX(QAbstractSeries *series) const;
-                QAbstractAxis *axisY(QAbstractSeries *series) const;
-                void setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Orientation orientation);
+                void addAxis(QAbstractAxis *axis,Qt::Alignment aligment);
+                void removeAxis(QAbstractAxis *axis);
+                QList<QAbstractAxis*> axes() const;
+                void removeAllAxes();
-                QList<QAbstractSeries *> series() const;
+                bool attachAxis(QAbstractSeries* series,QAbstractAxis *axis);
-                Domain *domain(QAbstractSeries *series) const;
+                bool detachAxis(QAbstractSeries* series,QAbstractAxis *axis);
-                void removeAxis(QAbstractAxis *axis);
                 void createDefaultAxes();
+                void zoomInDomain(const QRectF &rect);
+                void zoomOutDomain(const QRectF &rect);
+                void scrollDomain(qreal dx, qreal dy);
             Q_SIGNALS:
-                void seriesAdded(QAbstractSeries *series, Domain *domain);
+                void axisAdded(QAbstractAxis* axis);
-                void seriesRemoved(QAbstractSeries *series);
+                void axisRemoved(QAbstractAxis* axis);
-            //    void seriesUpdated(QAbstractSeries* series);
+                void seriesAdded(QAbstractSeries* series);
-                void axisAdded(QAbstractAxis *axis, Domain *domain);
+                void seriesRemoved(QAbstractSeries* series);
-                void axisRemoved(QAbstractAxis *axis);
             private:
-                void calculateDomain(QAbstractSeries *series, Domain *domain);
                 void createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation);
                 QAbstractAxis *createAxis(QAbstractAxis::AxisType type, Qt::Orientation orientation);
-                void initializeAxis(QAbstractAxis *axis, QAbstractSeries *series);
-                void removeAxes(QAbstractSeries *series);
-                void blockAxisSignals(bool enabled);
-                void createSeriesIndex(QAbstractSeries *series);
-                void removeSeriesIndex(QAbstractSeries *series);
             private:
-                QMap<QAbstractSeries *, QAbstractAxis *> m_seriesAxisXMap;
+                QList<QAbstractSeries *> m_seriesList;
-                QMap<QAbstractSeries *, QAbstractAxis *> m_seriesAxisYMap;
+                QList<QAbstractAxis *> m_axisList;
-                QMap<QAbstractSeries *, Domain *> m_seriesDomainMap;
+                QChart* m_chart;
-                QMap<int, QAbstractSeries *> m_indexSeriesMap;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartelement.cpp +9 -31

@@ -24,11 +24,12
24		24
25	QTCOMMERCIALCHART_BEGIN_NAMESPACE	25	QTCOMMERCIALCHART_BEGIN_NAMESPACE
26		26
27	ChartElement::ChartElement(~~ChartPresenter~~ *~~presenter~~)	27	ChartElement::ChartElement(QGraphicsItem* item):
28	: QObject(~~presenter~~),	28	QGraphicsObject(item),
29	m_presenter(~~presenter~~),	29	m_presenter(0),
30	m_~~domain~~(0)	30	m_themeManager(0)
31	{	31	{
		32
32	}	33	}
33		34
34	void ChartElement::setPresenter(ChartPresenter *presenter)	35	void ChartElement::setPresenter(ChartPresenter *presenter)
@@ -41,37 +42,14 ChartPresenter *ChartElement::presenter() const
41	return m_presenter;	42	return m_presenter;
42	}	43	}
43		44
44	void ChartElement::setDomain(Domain *domain)	45	void ChartElement::setThemeManager(ChartThemeManager *manager)
45	{
46	m_domain = domain;
47	}
48
49	Domain *ChartElement::domain() const
50	{
51	return m_domain;
52	}
53
54	void ChartElement::handleGeometryChanged(const QRectF &rect)
55	{
56	Q_UNUSED(rect);
57	qWarning() << "Slot not implemented";
58	}
59
60	void ChartElement::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
61	{	46	{
62	Q_UNUSED(minX);	47	m_themeManager = manager;
63	Q_UNUSED(maxX);
64	Q_UNUSED(minY);
65	Q_UNUSED(maxY);
66	qWarning() << "Slot not implemented";
67	}	48	}
68		49
69	void ChartElement::handleDomainUpdated()	50	ChartThemeManager* ChartElement::themeManager() const
70	{	51	{
71	qWarning() << "Slot not implemented";	52	return m_themeManager;
72	}	53	}
73		54
74
75	#include "moc_chartelement_p.cpp"
76
77	QTCOMMERCIALCHART_END_NAMESPACE	55	QTCOMMERCIALCHART_END_NAMESPACE

src/chartelement_p.h +9 -12

             #include "qchartglobal.h"
             #include <QObject>
             #include <QRect>
+            #include <QGraphicsObject>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartAnimator;
             class ChartPresenter;
             class ChartAnimation;
+            class ChartThemeManager;
             class Domain;
-            class ChartElement: public QObject
+            class ChartElement: public QGraphicsObject
             {
-                Q_OBJECT
             public:
-                explicit ChartElement(ChartPresenter *presenter);
+                explicit ChartElement(QGraphicsItem* item = 0);
-            public Q_SLOTS:
-                virtual void handleGeometryChanged(const QRectF &rect);
-                virtual void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
-                virtual void handleDomainUpdated();
                 virtual ChartAnimation *animation() const { return 0; }
+                virtual void setPresenter(ChartPresenter *presenter);
-                void setPresenter(ChartPresenter *presenter);
                 ChartPresenter *presenter() const;
-                void setDomain(Domain *domain);
+                virtual void setThemeManager(ChartThemeManager *manager);
-                Domain *domain() const;
+                ChartThemeManager* themeManager() const;
             private:
                 ChartPresenter *m_presenter;
-                Domain *m_domain;
+                ChartThemeManager *m_themeManager;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartitem_p.h +8 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class ChartItem : public QGraphicsItem, public ChartElement
+            class ChartItem : public ChartElement
             {
+            	Q_OBJECT
                 enum ChartItemTypes { AXIS_ITEM = UserType + 1, XYLINE_ITEM };
             public:
-                ChartItem(ChartPresenter *presenter) : QGraphicsItem(presenter ? presenter->rootItem() : 0), ChartElement(presenter) {}
+                ChartItem(QAbstractSeriesPrivate *series,QGraphicsItem* item);
+                QSharedPointer<Domain>  domain() const;
+            public Q_SLOTS:
+            	virtual void handleDomainUpdated();
+            private:
+                QAbstractSeriesPrivate* m_series;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartlayout.cpp +10 -13

                     return;
                 QList<ChartAxis *> axes = m_presenter->axisItems();
-                QList<ChartElement *> charts = m_presenter->chartItems();
                 ChartTitle *title = m_presenter->titleElement();
                 QLegend *legend = m_presenter->legend();
                 ChartBackground *background = m_presenter->backgroundElement();
                 contentGeometry = calculateAxisGeometry(contentGeometry, axes);
-                m_chartsRect = calculateChartsGeometry(contentGeometry, charts);
+                m_presenter->setGeometry(contentGeometry);
                 QGraphicsLayout::setGeometry(rect);
             }
                     if (!axis->isVisible())
                         continue;
                     QSizeF size = axis->effectiveSizeHint(Qt::PreferredSize);
                     //this is used to get single thick font size
                     QSizeF minSize = axis->effectiveSizeHint(Qt::MinimumSize);
                         minBottom.setHeight(minBottom.height() + minSize.height());
                         bottomCount++;
                         break;
+                    default:
+                        qWarning()<<"Axis is without alignment !";
+                        break;
                     }
                 }
                 qreal topOffset = 0;
                 qreal bottomOffset = 0;
-                foreach(ChartAxis* axis , axes) {
+                foreach(ChartElement *axisElement , axes) {
+                    //TODO fixme
+                    ChartAxis* axis = qobject_cast<ChartAxis*>(axisElement);
                     if (!axis->isVisible())
                         continue;
                 QSizeF bottom;
                 QSizeF top;
-                foreach (ChartAxis *axis , axes) {
+                foreach (ChartAxis *axis, axes) {
                     QSizeF size = axis->effectiveSizeHint(Qt::MinimumSize);
                 return result;
             }
-            QRectF ChartLayout::calculateChartsGeometry(const QRectF &geometry, const QList<ChartElement *>& charts) const
-                Q_ASSERT(geometry.isValid());
-                foreach (ChartElement *chart, charts)
-                    chart->handleGeometryChanged(geometry);
-                return geometry;
             QRectF ChartLayout::calculateLegendMinimum(const QRectF &geometry, QLegend *legend) const
             {
                 QSizeF minSize = legend->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, -1));

src/chartlayout_p.h 0 -5

             class QLegend;
             class ChartAxis;
             class ChartBackground;
-            class ChartElement;
             class ChartLayout : public QGraphicsLayout
             {
                 QMargins margins() const;
                 void setGeometry(const QRectF &rect);
-                QRectF chartsGeometry() const { return m_chartsRect;}
             protected:
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
                 QRectF calculateBackgroundGeometry(const QRectF &geometry, ChartBackground *background) const;
                 QRectF calculateContentGeometry(const QRectF &geometry) const;
                 QRectF calculateTitleGeometry(const QRectF &geometry, ChartTitle *title) const;
-                QRectF calculateChartGeometry(const QRectF &geometry, const QList<ChartAxis *>& axes) const;
                 QRectF calculateLegendGeometry(const QRectF &geometry, QLegend *legend) const;
                 QRectF calculateAxisGeometry(const QRectF &geometry, const QList<ChartAxis *>& axes) const;
-                QRectF calculateChartsGeometry(const QRectF &geometry, const QList<ChartElement *>& charts) const;
                 QRectF calculateBackgroundMinimum(const QRectF &minimum) const;
                 QRectF calculateContentMinimum(const QRectF &minimum) const;
                 QRectF calculateTitleMinimum(const QRectF &minimum, ChartTitle *title) const;
                 QMargins m_margins;
                 QRectF m_minChartRect;
                 QRectF m_minAxisRect;
-                QRectF m_chartsRect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +62 -131

@@ -19,11 +19,11
19	****************************************************************************/	19	****************************************************************************/
20	#include "chartpresenter_p.h"	20	#include "chartpresenter_p.h"
21	#include "qchart.h"	21	#include "qchart.h"
		22	#include "chartitem_p.h"
22	#include "qchart_p.h"	23	#include "qchart_p.h"
23	#include "qabstractaxis.h"	24	#include "qabstractaxis.h"
24	#include "qabstractaxis_p.h"	25	#include "qabstractaxis_p.h"
25	#include "chartdataset_p.h"	26	#include "chartdataset_p.h"
26	#include "charttheme_p.h"
27	#include "chartanimation_p.h"	27	#include "chartanimation_p.h"
28	#include "qabstractseries_p.h"	28	#include "qabstractseries_p.h"
29	#include "qareaseries.h"	29	#include "qareaseries.h"
@@ -35,11 +35,9
35		35
36	QTCOMMERCIALCHART_BEGIN_NAMESPACE	36	QTCOMMERCIALCHART_BEGIN_NAMESPACE
37		37
38	ChartPresenter::ChartPresenter(QChart chart, ~~ChartDataSet~~ ~~dataset~~)	38	ChartPresenter::ChartPresenter(QChart *chart)
39	: QObject(chart),	39	: QObject(chart),
40	m_chart(chart),	40	m_chart(chart),
41	m_dataset(dataset),
42	m_chartTheme(0),
43	m_options(QChart::NoAnimation),	41	m_options(QChart::NoAnimation),
44	m_state(ShowState),	42	m_state(ShowState),
45	m_layout(new ChartLayout(this)),	43	m_layout(new ChartLayout(this)),
@@ -51,164 +49,97 ChartPresenter::ChartPresenter(QChart chart, ChartDataSet dataset)
51		49
52	ChartPresenter::~ChartPresenter()	50	ChartPresenter::~ChartPresenter()
53	{	51	{
54	delete m_chartTheme;	52
55	}	53	}
56		54
57	void ChartPresenter::handleAxisAdded(QAbstractAxis axis, Domain domain)	55	void ChartPresenter::setGeometry(const QRectF rect)
58	{	56	{
59	ChartAxis *item = axis->d_ptr->createGraphics(this);	57	if(m_rect != rect) {
60	item->setDomain(domain);	58	m_rect=rect;
61		59	foreach (ChartItem *chart, m_chartItems){
62	if (m_options.testFlag(QChart::GridAxisAnimations))	60	chart->domain()->setSize(rect.size());
63	item->setAnimation(new AxisAnimation(item));	61	chart->setPos(rect.topLeft());
64		62	}
65	QObject::connect(domain, SIGNAL(updated()), item, SLOT(handleDomainUpdated()));	63	}
		64	}
66		65
67	//initialize	66	QRectF ChartPresenter::geometry() const
68	domain->emitUpdated();	67	{
69	m_chartTheme->decorate(axis);	68	return m_rect;
70	axis->d_ptr->setDirty(false);	69	}
71	axis->d_ptr->emitUpdated();
72		70
73	m_axisItems.insert(axis, item);	71	void ChartPresenter::handleAxisAdded(QAbstractAxis *axis)
		72	{
		73	qDebug()<<__FUNCTION__;
		74	axis->d_ptr->initializeGraphics(rootItem());
		75	axis->d_ptr->initializeAnimations(m_options);
		76	ChartAxis *item = axis->d_ptr->axisItem();
		77	item->setPresenter(this);
		78	item->setThemeManager(m_chart->d_ptr->m_themeManager);
		79	m_axisItems<<item;
		80	m_axes<<axis;
74	m_layout->invalidate();	81	m_layout->invalidate();
75	}	82	}
76		83
77	void ChartPresenter::handleAxisRemoved(QAbstractAxis *axis)	84	void ChartPresenter::handleAxisRemoved(QAbstractAxis *axis)
78	{	85	{
79	ChartAxis *item = m_axisItems.take(axis);	86	qDebug()<<__FUNCTION__;
80	Q_ASSERT(item);	87	ChartAxis *item = axis->d_ptr->m_item.take();
81	item->hide();	88	item->hide();
82	item->disconnect();	89	item->disconnect();
83	QObject::disconnect(this, 0, item, 0);
84	item->deleteLater();	90	item->deleteLater();
		91	m_axisItems.removeAll(item);
		92	m_axes.removeAll(axis);
85	m_layout->invalidate();	93	m_layout->invalidate();
86	}	94	}
87		95
88		96
89	void ChartPresenter::handleSeriesAdded(QAbstractSeries series, ~~Domain~~ ~~domain~~)	97	void ChartPresenter::handleSeriesAdded(QAbstractSeries *series)
90	{	98	{
91	ChartElement *item = series->d_ptr->createGraphics(this);	99	qDebug()<<__FUNCTION__;
92	Q_ASSERT(item);	100	series->d_ptr->initializeGraphics(rootItem());
93	item->setDomain(domain);	101	series->d_ptr->initializeAnimations(m_options);
94		102	ChartItem *chart = series->d_ptr->chartItem();
95	QObject::connect(domain, SIGNAL(updated()), item, SLOT(handleDomainUpdated()));	103	chart->setPresenter(this);
96	//initialize	104	chart->setThemeManager(m_chart->d_ptr->m_themeManager);
97	item->handleDomainUpdated();	105	chart->domain()->setSize(m_rect.size());
98		106	chart->setPos(m_rect.topLeft());
99	m_chartItems.insert(series, item);	107	chart->handleDomainUpdated(); //this could be moved to intializeGraphics when animator is refactored
		108	m_chartItems<<chart;
		109	m_series<<series;
100	m_layout->invalidate();	110	m_layout->invalidate();
101	}	111	}
102		112
103	void ChartPresenter::handleSeriesRemoved(QAbstractSeries *series)	113	void ChartPresenter::handleSeriesRemoved(QAbstractSeries *series)
104	{	114	{
105	ChartElement *item = m_chartItems.take(series);	115	qDebug()<<__FUNCTION__;
106	Q_ASSERT(item);	116	ChartItem *chart = series->d_ptr->m_item.take();
107	item->deleteLater();	117	chart->hide();
108	}	118	chart->disconnect();
109		119	chart->deleteLater();
110	void ChartPresenter::setTheme(QChart::ChartTheme theme, bool force)	120	m_chartItems.removeAll(chart);
111	{	121	m_series.removeAll(series);
112	if (m_chartTheme && m_chartTheme->id() == theme)	122	m_layout->invalidate();
113	return;
114	delete m_chartTheme;
115	m_chartTheme = ChartTheme::createTheme(theme);
116	m_chartTheme->setForced(force);
117	m_chartTheme->decorate(m_chart);
118	m_chartTheme->decorate(m_chart->legend());
119	resetAllElements();
120
121	// We do not want "force" to stay on.
122	// Bar/pie are calling decorate when adding/removing slices/bars which means
123	// that to preserve users colors "force" must not be on.
124	m_chartTheme->setForced(false);
125	}
126
127	QChart::ChartTheme ChartPresenter::theme()
128	{
129	return m_chartTheme->id();
130	}	123	}
131		124
132	void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)	125	void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
133	{	126	{
134	if (m_options != options) {	127	if (m_options != options) {
135	m_options = options;	128	m_options = options;
136	resetAllElements();
137	}
138		129
139	}	130	foreach(QAbstractSeries* series, m_series){
140		131	series->d_ptr->initializeAnimations(m_options);
141	void ChartPresenter::resetAllElements()	132	}
142	{	133	foreach(QAbstractAxis* axis, m_axes){
143	QMapIterator<QAbstractAxis , ChartAxis > i(m_axisItems);	134	axis->d_ptr->initializeAnimations(m_options);
144	while (i.hasNext()) {	135	}
145	i.next();
146	Domain *domain = i.value()->domain();
147	QAbstractAxis *axis = i.key();
148	handleAxisRemoved(axis);
149	handleAxisAdded(axis, domain);
150	}
151
152	QMapIterator<QAbstractSeries , ChartElement > j(m_chartItems);
153	while (j.hasNext()) {
154	j.next();
155	Domain *domain = j.value()->domain();
156	QAbstractSeries *series = j.key();
157	handleSeriesRemoved(series);
158	handleSeriesAdded(series, domain);
159	}	136	}
160
161	layout()->invalidate();
162	}	137	}
163		138
164	void ChartPresenter::zoomIn(qreal factor)	139	void ChartPresenter::setState(State state,QPointF point)
165	{	140	{
166	QRectF rect = m_layout->chartsGeometry();	141	m_state=state;
167	rect.setWidth(rect.width() / factor);	142	m_statePoint=point;
168	rect.setHeight(rect.height() / factor);
169	rect.moveCenter(m_layout->chartsGeometry().center());
170	zoomIn(rect);
171	}
172
173	void ChartPresenter::zoomIn(const QRectF &rect)
174	{
175	QRectF r = rect.normalized();
176	r.translate(-m_layout->chartsGeometry().topLeft());
177	if (!r.isValid())
178	return;
179
180	m_state = ZoomInState;
181	m_statePoint = QPointF(r.center().x() / m_layout->chartsGeometry().width(), r.center().y() / m_layout->chartsGeometry().height());
182	m_dataset->zoomInDomain(r, m_layout->chartsGeometry().size());
183	m_state = ShowState;
184	}
185
186	void ChartPresenter::zoomOut(qreal factor)
187	{
188	m_state = ZoomOutState;
189
190	QRectF chartRect;
191	chartRect.setSize(m_layout->chartsGeometry().size());
192
193	QRectF rect;
194	rect.setSize(chartRect.size() / factor);
195	rect.moveCenter(chartRect.center());
196	if (!rect.isValid())
197	return;
198	m_statePoint = QPointF(rect.center().x() / m_layout->chartsGeometry().width(), rect.center().y() / m_layout->chartsGeometry().height());
199	m_dataset->zoomOutDomain(rect, chartRect.size());
200	m_state = ShowState;
201	}
202
203	void ChartPresenter::scroll(qreal dx, qreal dy)
204	{
205	if (dx < 0) m_state = ScrollLeftState;
206	if (dx > 0) m_state = ScrollRightState;
207	if (dy < 0) m_state = ScrollUpState;
208	if (dy > 0) m_state = ScrollDownState;
209
210	m_dataset->scrollDomain(dx, dy, m_layout->chartsGeometry().size());
211	m_state = ShowState;
212	}	143	}
213		144
214	QChart::AnimationOptions ChartPresenter::animationOptions() const	145	QChart::AnimationOptions ChartPresenter::animationOptions() const
@@ -370,12 +301,12 ChartBackground *ChartPresenter::backgroundElement()
370		301
371	QList<ChartAxis *> ChartPresenter::axisItems() const	302	QList<ChartAxis *> ChartPresenter::axisItems() const
372	{	303	{
373	return m_axisItems.~~values~~();	304	return m_axisItems;
374	}	305	}
375		306
376	QList<Chart~~Element~~ *> ChartPresenter::chartItems() const	307	QList<ChartItem *> ChartPresenter::chartItems() const
377	{	308	{
378	return m_chartItems.~~values~~();	309	return m_chartItems;
379	}	310	}
380		311
381	ChartTitle *ChartPresenter::titleElement()	312	ChartTitle *ChartPresenter::titleElement()

src/chartpresenter_p.h +22 -24

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class ChartElement;
+            class ChartItem;
+            class AxisItem;
             class QAbstractSeries;
             class ChartDataSet;
             class Domain;
             class ChartAxis;
-            class ChartTheme;
             class ChartAnimator;
             class ChartBackground;
             class ChartTitle;
                     ZoomOutState
                 };
-                ChartPresenter(QChart *chart, ChartDataSet *dataset);
+                ChartPresenter(QChart *chart);
                 virtual ~ChartPresenter();
-                ChartTheme *chartTheme() const { return m_chartTheme; }
-                ChartDataSet *dataSet() const { return m_dataset; }
+                void setGeometry(QRectF rect);
-                QGraphicsItem *rootItem() const { return m_chart; }
+                QRectF geometry() const;
+                QGraphicsItem *rootItem(){ return m_chart; }
                 ChartBackground *backgroundElement();
                 ChartTitle *titleElement();
                 QList<ChartAxis *> axisItems() const;
-                QList<ChartElement *> chartItems() const;
+                QList<ChartItem *> chartItems() const;
+                ChartItem* chartElement(QAbstractSeries* series) const;
+                ChartAxis* chartElement(QAbstractAxis* axis) const;
                 QLegend *legend();
                 void setVisible(bool visible);
-                void setTheme(QChart::ChartTheme theme, bool force = true);
-                QChart::ChartTheme theme();
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
-                void zoomIn(qreal factor);
-                void zoomIn(const QRectF &rect);
-                void zoomOut(qreal factor);
-                void scroll(qreal dx, qreal dy);
                 void startAnimation(ChartAnimation *animation);
+                //TODO refactor
+                void setState(State state,QPointF point);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
-                void resetAllElements();
                 ChartLayout *layout();
             private:
                 void createTitleItem();
             public Q_SLOTS:
-                void handleSeriesAdded(QAbstractSeries *series, Domain *domain);
+                void handleSeriesAdded(QAbstractSeries *series);
                 void handleSeriesRemoved(QAbstractSeries *series);
-                void handleAxisAdded(QAbstractAxis *axis, Domain *domain);
+                void handleAxisAdded(QAbstractAxis *axis);
                 void handleAxisRemoved(QAbstractAxis *axis);
             private Q_SLOTS:
             private:
                 QChart *m_chart;
-                ChartDataSet *m_dataset;
+                QList<ChartItem *> m_chartItems;
-                ChartTheme *m_chartTheme;
+                QList<ChartAxis *> m_axisItems;
-                QMap<QAbstractSeries *, ChartElement *> m_chartItems;
+                QList<QAbstractSeries *> m_series;
-                QMap<QAbstractAxis *, ChartAxis *> m_axisItems;
+                QList<QAbstractAxis *> m_axes;
                 QChart::AnimationOptions m_options;
                 State m_state;
                 QPointF m_statePoint;
                 ChartLayout *m_layout;
                 ChartBackground *m_background;
                 ChartTitle *m_title;
+                QRectF m_rect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain.cpp +115 -24

@@ -20,6 +20,7
20		20
21	#include "domain_p.h"	21	#include "domain_p.h"
22	#include "qabstractaxis_p.h"	22	#include "qabstractaxis_p.h"
		23	#include <qmath.h>
23		24
24	QTCOMMERCIALCHART_BEGIN_NAMESPACE	25	QTCOMMERCIALCHART_BEGIN_NAMESPACE
25		26
@@ -28,7 +29,8 Domain::Domain(QObject *parent)
28	m_minX(0),	29	m_minX(0),
29	m_maxX(0),	30	m_maxX(0),
30	m_minY(0),	31	m_minY(0),
31	m_maxY(0)	32	m_maxY(0),
		33	m_axisSignalsBlocked(false)
32	{	34	{
33	}	35	}
34		36
@@ -36,6 +38,20 Domain::~Domain()
36	{	38	{
37	}	39	}
38		40
		41	void Domain::setSize(const QSizeF& size)
		42	{
		43	if(m_size!=size)
		44	{
		45	m_size=size;
		46	emit updated();
		47	}
		48	}
		49
		50	QSizeF Domain::size() const
		51	{
		52	return m_size;
		53	}
		54
39	void Domain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)	55	void Domain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
40	{	56	{
41	bool axisXChanged = false;	57	bool axisXChanged = false;
@@ -45,14 +61,14 void Domain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
45	m_minX = minX;	61	m_minX = minX;
46	m_maxX = maxX;	62	m_maxX = maxX;
47	axisXChanged = true;	63	axisXChanged = true;
48	emit rangeXChanged(m_minX, m_maxX);	64	emit rangeHorizontalChanged(m_minX, m_maxX);
49	}	65	}
50		66
51	if (!qFuzzyCompare(m_minY, minY) \|\| !qFuzzyCompare(m_maxY, maxY)) {	67	if (!qFuzzyCompare(m_minY, minY) \|\| !qFuzzyCompare(m_maxY, maxY)) {
52	m_minY = minY;	68	m_minY = minY;
53	m_maxY = maxY;	69	m_maxY = maxY;
54	axisYChanged = true;	70	axisYChanged = true;
55	emit rangeYChanged(m_minY, m_maxY);	71	emit rangeVerticalChanged(m_minY, m_maxY);
56	}	72	}
57		73
58	if (axisXChanged \|\| axisYChanged)	74	if (axisXChanged \|\| axisYChanged)
@@ -103,13 +119,13 qreal Domain::spanY() const
103		119
104	bool Domain::isEmpty() const	120	bool Domain::isEmpty() const
105	{	121	{
106	return qFuzzyCompare(spanX(), 0) \|\| qFuzzyCompare(spanY(), 0);	122	return qFuzzyCompare(spanX(),0) \|\| qFuzzyCompare(spanY(),0) \|\| m_size.isEmpty() ;
107	}	123	}
108		124
109	void Domain::zoomIn(const QRectF &rect, ~~const~~ ~~QSizeF~~ &~~size~~)	125	void Domain::zoomIn(const QRectF &rect)
110	{	126	{
111	qreal dx = spanX() / size.width();	127	qreal dx = spanX() / m_size.width();
112	qreal dy = spanY() / size.height();	128	qreal dy = spanY() / m_size.height();
113		129
114	qreal maxX = m_maxX;	130	qreal maxX = m_maxX;
115	qreal minX = m_minX;	131	qreal minX = m_minX;
@@ -124,7 +140,7 void Domain::zoomIn(const QRectF &rect, const QSizeF &size)
124	setRange(minX, maxX, minY, maxY);	140	setRange(minX, maxX, minY, maxY);
125	}	141	}
126		142
127	void Domain::zoomOut(const QRectF &rect, ~~const~~ ~~QSizeF~~ &~~size~~)	143	void Domain::zoomOut(const QRectF &rect)
128	{	144	{
129	qreal dx = spanX() / rect.width();	145	qreal dx = spanX() / rect.width();
130	qreal dy = spanY() / rect.height();	146	qreal dy = spanY() / rect.height();
@@ -135,17 +151,17 void Domain::zoomOut(const QRectF &rect, const QSizeF &size)
135	qreal maxY = m_maxY;	151	qreal maxY = m_maxY;
136		152
137	minX = maxX - dx * rect.right();	153	minX = maxX - dx * rect.right();
138	maxX = minX + dx * size.width();	154	maxX = minX + dx * m_size.width();
139	maxY = minY + dy * rect.bottom();	155	maxY = minY + dy * rect.bottom();
140	minY = maxY - dy * size.height();	156	minY = maxY - dy * m_size.height();
141		157
142	setRange(minX, maxX, minY, maxY);	158	setRange(minX, maxX, minY, maxY);
143	}	159	}
144		160
145	void Domain::move(qreal dx, qreal dy, ~~const~~ ~~QSizeF~~ &~~size~~)	161	void Domain::move(qreal dx, qreal dy)
146	{	162	{
147	qreal x = spanX() / size.width();	163	qreal x = spanX() / m_size.width();
148	qreal y = spanY() / size.height();	164	qreal y = spanY() / m_size.height();
149		165
150	qreal maxX = m_maxX;	166	qreal maxX = m_maxX;
151	qreal minX = m_minX;	167	qreal minX = m_minX;
@@ -163,22 +179,97 void Domain::move(qreal dx, qreal dy, const QSizeF &size)
163	setRange(minX, maxX, minY, maxY);	179	setRange(minX, maxX, minY, maxY);
164	}	180	}
165		181
166	void Domain::emitUpdated()	182	QPointF Domain::calculateGeometryPoint(const QPointF &point) const
167	{	183	{
168	emit updated();	184	const qreal deltaX = m_size.width() / (m_maxX - m_minX);
		185	const qreal deltaY = m_size.height() / (m_maxY - m_minY);
		186	qreal x = (point.x() - m_minX) * deltaX;
		187	qreal y = (point.y() - m_minY) * -deltaY + m_size.height();
		188	return QPointF(x, y);
169	}	189	}
170		190
171	void Domain::handleAxisUpdated()	191	QVector<QPointF> Domain::calculateGeometryPoints(const QList<QPointF>& vector) const
172	{	192	{
173	QAbstractAxisPrivate axis = qobject_cast<QAbstractAxisPrivate >(sender());	193	const qreal deltaX = m_size.width() / (m_maxX - m_minX);
174	Q_ASSERT(axis);	194	const qreal deltaY = m_size.height() / (m_maxY - m_minY);
175	axis->setDirty(false);	195
176	if (axis->orientation() == Qt::Horizontal)	196	QVector<QPointF> result;
177	setRangeX(axis->min(), axis->max());	197	result.resize(vector.count());
178	else if (axis->orientation() == Qt::Vertical)	198
179	setRangeY(axis->min(), axis->max());	199	for (int i = 0; i < vector.count(); ++i) {
		200	qreal x = (vector[i].x() - m_minX) * deltaX;
		201	qreal y = (vector[i].y() - m_minY) * -deltaY + m_size.height();
		202	result[i].setX(x);
		203	result[i].setY(y);
		204	}
		205	return result;
180	}	206	}
181		207
		208	QPointF Domain::calculateDomainPoint(const QPointF &point) const
		209	{
		210	const qreal deltaX = m_size.width() / (m_maxX - m_minX);
		211	const qreal deltaY = m_size.height() / (m_maxY - m_minY);
		212	qreal x = point.x() / deltaX + m_minX;
		213	qreal y = (point.y() - m_size.height()) / (-deltaY) + m_minY;
		214	return QPointF(x, y);
		215	}
		216
		217	// handlers
		218
		219	void Domain::handleVerticalAxisRangeChanged(qreal min, qreal max)
		220	{
		221	if(!m_axisSignalsBlocked)
		222	setRangeY(min, max);
		223	}
		224
		225	void Domain::handleHorizontalAxisRangeChanged(qreal min, qreal max)
		226	{
		227	if(!m_axisSignalsBlocked)
		228	setRangeX(min, max);
		229	}
		230
		231	void Domain::blockAxisSignals(bool block)
		232	{
		233	m_axisSignalsBlocked=block;
		234	}
		235
		236	//algorithm defined by Paul S.Heckbert GraphicalGems I
		237
		238	void Domain::looseNiceNumbers(qreal &min, qreal &max, int &ticksCount)
		239	{
		240	qreal range = niceNumber(max - min, true); //range with ceiling
		241	qreal step = niceNumber(range / (ticksCount - 1), false);
		242	min = qFloor(min / step);
		243	max = qCeil(max / step);
		244	ticksCount = int(max - min) + 1;
		245	min *= step;
		246	max *= step;
		247	}
		248
		249	//nice numbers can be expressed as form of 110^n, 2 10^n or 5*10^n
		250
		251	qreal Domain::niceNumber(qreal x, bool ceiling)
		252	{
		253	qreal z = qPow(10, qFloor(log10(x))); //find corresponding number of the form of 10^n than is smaller than x
		254	qreal q = x / z; //q<10 && q>=1;
		255
		256	if (ceiling) {
		257	if (q <= 1.0) q = 1;
		258	else if (q <= 2.0) q = 2;
		259	else if (q <= 5.0) q = 5;
		260	else q = 10;
		261	} else {
		262	if (q < 1.5) q = 1;
		263	else if (q < 3.0) q = 2;
		264	else if (q < 7.0) q = 5;
		265	else q = 10;
		266	}
		267	return q * z;
		268	}
		269
		270
		271	// operators
		272
182	bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const Domain &domain1, const Domain &domain2)	273	bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const Domain &domain1, const Domain &domain2)
183	{	274	{
184	return (qFuzzyCompare(domain1.m_maxX, domain2.m_maxX) &&	275	return (qFuzzyCompare(domain1.m_maxX, domain2.m_maxX) &&
@@ -196,7 +287,7 bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const Domain &domain1, const
196		287
197	QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const Domain &domain)	288	QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const Domain &domain)
198	{	289	{
199	dbg.nospace() << "Domain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')';	290	dbg.nospace() << "Domain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
200	return dbg.maybeSpace();	291	return dbg.maybeSpace();
201	}	292	}
202		293

src/domain_p.h +22 -7

                 explicit Domain(QObject *object = 0);
                 virtual ~Domain();
+                void setSize(const QSizeF& size);
+                QSizeF size() const;
                 void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void setRangeX(qreal min, qreal max);
                 void setRangeY(qreal min, qreal max);
                 qreal spanY() const;
                 bool isEmpty() const;
+                void blockAxisSignals(bool block);
+                bool axisSignalsBlocked() const { return m_axisSignalsBlocked; }
                 friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const Domain &domain1, const Domain &domain2);
                 friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const Domain &domain1, const Domain &domain2);
                 friend QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const Domain &domain);
-                void zoomIn(const QRectF &rect, const QSizeF &size);
+                void zoomIn(const QRectF &rect);
-                void zoomOut(const QRectF &rect, const QSizeF &size);
+                void zoomOut(const QRectF &rect);
-                void move(qreal dx, qreal dy, const QSizeF &size);
+                void move(qreal dx, qreal dy);
-                void emitUpdated();
+                QPointF calculateGeometryPoint(const QPointF &point) const;
+                QPointF calculateDomainPoint(const QPointF &point) const;
+                QVector<QPointF> calculateGeometryPoints(const QList<QPointF>& vector) const;
+                static void looseNiceNumbers(qreal &min, qreal &max, int &ticksCount);
+                static qreal niceNumber(qreal x, bool ceiling);
             Q_SIGNALS:
                 void updated();
-                void rangeXChanged(qreal min, qreal max);
+                void rangeHorizontalChanged(qreal min, qreal max);
-                void rangeYChanged(qreal min, qreal max);
+                void rangeVerticalChanged(qreal min, qreal max);
             public Q_SLOTS:
-                void handleAxisUpdated();
+                void handleVerticalAxisRangeChanged(qreal min,qreal max);
+                void handleHorizontalAxisRangeChanged(qreal min,qreal max);
             private:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
+                QSizeF m_size;
+                bool m_axisSignalsBlocked;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.cpp +8 -7

             #include "qlegendmarker.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
+            #include "chartdataset_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QGraphicsItemGroup>
             {
                 setZValue(ChartPresenter::LegendZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
-                QObject::connect(chart->d_ptr->m_dataset, SIGNAL(seriesAdded(QAbstractSeries*,Domain*)), d_ptr.data(), SLOT(handleSeriesAdded(QAbstractSeries*)));
+                QObject::connect(chart->d_ptr->m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), d_ptr.data(), SLOT(handleSeriesAdded(QAbstractSeries*)));
                 QObject::connect(chart->d_ptr->m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), d_ptr.data(), SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 setLayout(d_ptr->m_layout);
             }
             void QLegend::setFont(const QFont &font)
             {
-                if (d_ptr->m_font != font)
+                if (d_ptr->m_font != font) {
                     d_ptr->m_font = font;
+                    foreach (QLegendMarker *marker, d_ptr->markers()) {
-                foreach (QLegendMarker *marker, d_ptr->markers()) {
+                        marker->setFont(d_ptr->m_font);
-                    marker->setFont(d_ptr->m_font);
+                    layout()->invalidate();
+                    emit fontChanged(font);
                 }
-                layout()->invalidate();
-                emit fontChanged(font);
             }
             QFont QLegend::font() const

src/linechart/linechartitem.cpp +9 -11

             #include "qlineseries.h"
             #include "qlineseries_p.h"
             #include "chartpresenter_p.h"
+            #include "domain_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             const qreal mouseEventMinWidth(12);
-            LineChartItem::LineChartItem(QLineSeries *series, ChartPresenter *presenter)
+            LineChartItem::LineChartItem(QLineSeries *series,QGraphicsItem* item)
-                : XYChart(series, presenter),
+                : XYChart(series,item),
-                  QGraphicsItem(presenter ? presenter->rootItem() : 0),
                   m_series(series),
                   m_pointsVisible(false)
             {
                 m_path = stroker.createStroke(linePath);
                 m_rect = m_path.boundingRect();
-                setPos(origin());
             }
             void LineChartItem::handleUpdated()
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(m_linePen.color());
-                painter->setClipRect(clipRect());
+                painter->setClipRect(QRectF(QPointF(0,0),domain()->size()));
                 if (m_pointsVisible) {
                     painter->drawPath(m_linePath);
             void LineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
-                emit XYChart::clicked(calculateDomainPoint(event->pos()));
+                emit XYChart::clicked(domain()->calculateDomainPoint(event->pos()));
                 QGraphicsItem::mousePressEvent(event);
             }
             void LineChartItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
-                emit XYChart::hovered(calculateDomainPoint(event->pos()), true);
+                emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), true);
                 event->accept();
-            //    QGraphicsItem::hoverEnterEvent(event);
+                //QGraphicsItem::hoverEnterEvent(event);
             }
             void LineChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
-                emit XYChart::hovered(calculateDomainPoint(event->pos()), false);
+                emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), false);
                 event->accept();
-            //    QGraphicsItem::hoverEnterEvent(event);
+                //QGraphicsItem::hoverEnterEvent(event);
             }
             #include "moc_linechartitem_p.cpp"

src/linechart/linechartitem_p.h +2 -2

             class QLineSeries;
             class ChartPresenter;
-            class LineChartItem :  public XYChart , public QGraphicsItem
+            class LineChartItem :  public XYChart
             {
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsItem)
             public:
-                explicit LineChartItem(QLineSeries *series, ChartPresenter *presenter);
+                explicit LineChartItem(QLineSeries *series, QGraphicsItem* item = 0);
                 ~LineChartItem() {}
                 //from QGraphicsItem

src/linechart/qlineseries.cpp +19 -8

             QLineSeries::~QLineSeries()
             {
                 Q_D(QLineSeries);
-                if (d->m_dataset)
+                if (d->m_chart)
-                    d->m_dataset->removeSeries(this);
+                    d->m_chart->removeSeries(this);
             }
             QAbstractSeries::SeriesType QLineSeries::type() const
             };
-            ChartElement *QLineSeriesPrivate::createGraphics(ChartPresenter *presenter)
+            void QLineSeriesPrivate::initializeGraphics(QGraphicsItem *parent)
             {
                 Q_Q(QLineSeries);
-                LineChartItem *line = new LineChartItem(q, presenter);
+                LineChartItem *line = new LineChartItem(q,parent);
-                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
+                m_item.reset(line);
-                    line->setAnimation(new XYAnimation(line));
+                QAbstractSeriesPrivate::initializeGraphics(parent);
-                presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
-                return line;
+            void QLineSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
+            {
+                Q_Q(QLineSeries);
+                const QList<QColor> colors = theme->seriesColors();
+                QPen pen;
+                if (forced || pen == m_pen) {
+                    pen.setColor(colors.at(index % colors.size()));
+                    pen.setWidthF(2);
+                    q->setPen(pen);
+                }
             }
             #include "moc_qlineseries.cpp"

src/linechart/qlineseries_p.h +2 -1

             {
             public:
                 QLineSeriesPrivate(QLineSeries *q);
-                ChartElement *createGraphics(ChartPresenter *presenter);
+                void initializeGraphics(QGraphicsItem* parent);
+                void initializeTheme(int index, ChartTheme* theme, bool forced = false);
             private:
                 Q_DECLARE_PUBLIC(QLineSeries);

src/piechart/piechartitem.cpp +12 -41

@@ -32,8 +32,8
32		32
33	QTCOMMERCIALCHART_BEGIN_NAMESPACE	33	QTCOMMERCIALCHART_BEGIN_NAMESPACE
34		34
35	PieChartItem::PieChartItem(QPieSeries series, ~~ChartPresenter~~ ~~presenter~~)	35	PieChartItem::PieChartItem(QPieSeries series, QGraphicsItem item)
36	: ChartItem(~~presenter~~),	36	: ChartItem(series->d_func(),item),
37	m_series(series),	37	m_series(series),
38	m_animation(0)	38	m_animation(0)
39	{	39	{
@@ -70,46 +70,17 ChartAnimation *PieChartItem::animation() const
70	return m_animation;	70	return m_animation;
71	}	71	}
72		72
73	void PieChartItem::handleGeometryChanged(const QRectF &rect)
74	{
75	prepareGeometryChange();
76	m_rect = rect;
77	updateLayout();
78
79	// This is for delayed initialization of the slice items during startup.
80	// It ensures that startup animation originates from the correct position.
81	if (m_sliceItems.isEmpty())
82	handleSlicesAdded(m_series->slices());
83	}
84
85	void PieChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
86	{
87	Q_UNUSED(minX);
88	Q_UNUSED(maxX);
89	Q_UNUSED(minY);
90	Q_UNUSED(maxY);
91	// does not apply to pie
92	}
93
94	void PieChartItem::handleDomainUpdated()	73	void PieChartItem::handleDomainUpdated()
95	{	74	{
96	// does not apply to pie	75	QRectF rect(QPointF(0,0),domain()->size());
97	}	76	if(m_rect!=rect){
98		77	prepareGeometryChange();
99	void PieChartItem::rangeXChanged(qreal min, qreal max, int tickXCount)	78	m_rect = rect;
100	{	79	updateLayout();
101	Q_UNUSED(min);
102	Q_UNUSED(max);
103	Q_UNUSED(tickXCount);
104	// does not apply to pie
105	}
106		80
107	void PieChartItem::rangeYChanged(qreal min, qreal max, int tickYCount)	81	if (m_sliceItems.isEmpty())
108	{	82	handleSlicesAdded(m_series->slices());
109	Q_UNUSED(min);	83	}
110	Q_UNUSED(max);
111	Q_UNUSED(tickYCount);
112	// does not apply to pie
113	}	84	}
114		85
115	void PieChartItem::updateLayout()	86	void PieChartItem::updateLayout()
@@ -149,7 +120,7 void PieChartItem::handleSlicesAdded(QList<QPieSlice *> slices)
149	if (!m_rect.isValid() && m_sliceItems.isEmpty())	120	if (!m_rect.isValid() && m_sliceItems.isEmpty())
150	return;	121	return;
151		122
152	presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));	123	themeManager()->updateSeries(m_series);
153		124
154	bool startupAnimation = m_sliceItems.isEmpty();	125	bool startupAnimation = m_sliceItems.isEmpty();
155		126
@@ -185,7 +156,7 void PieChartItem::handleSlicesAdded(QList<QPieSlice *> slices)
185		156
186	void PieChartItem::handleSlicesRemoved(QList<QPieSlice *> slices)	157	void PieChartItem::handleSlicesRemoved(QList<QPieSlice *> slices)
187	{	158	{
188	presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));	159	themeManager()->updateSeries(m_series);
189		160
190	foreach (QPieSlice *slice, slices) {	161	foreach (QPieSlice *slice, slices) {
191		162

src/piechart/piechartitem_p.h +1 -5

                 Q_OBJECT
             public:
-                explicit PieChartItem(QPieSeries *series, ChartPresenter *presenter);
+                explicit PieChartItem(QPieSeries *series, QGraphicsItem* item = 0);
                 ~PieChartItem();
                 // from QGraphicsItem
             public Q_SLOTS:
                 // from Chart
-                virtual void handleGeometryChanged(const QRectF &rect);
-                virtual void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 virtual void handleDomainUpdated();
-                virtual void rangeXChanged(qreal min, qreal max, int tickXCount);
-                virtual void rangeYChanged(qreal min, qreal max, int tickYCount);
                 void updateLayout();
                 void handleSlicesAdded(QList<QPieSlice *> slices);

src/piechart/qpieseries.cpp +57 -10

@@ -834,20 +834,29 void QPieSeriesPrivate::sliceHovered(bool state)
834	emit q->hovered(slice, state);	834	emit q->hovered(slice, state);
835	}	835	}
836		836
837	void QPieSeriesPrivate::~~scal~~eDomain(~~Domain~~ &~~domain~~)	837	void QPieSeriesPrivate::initializeDomain()
838	{	838	{
839	Q_UNUSED(domain);
840	// does not apply to pie	839	// does not apply to pie
841	}	840	}
842		841
843	ChartElement QPieSeriesPrivate::createGraphics(ChartPresenter presenter)	842	void QPieSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
844	{	843	{
845	Q_Q(QPieSeries);	844	Q_Q(QPieSeries);
846	PieChartItem *pie = new PieChartItem(q, presenter);	845	PieChartItem *pie = new PieChartItem(q,parent);
847	if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))	846	m_item.reset(pie);
848	pie->setAnimation(new PieAnimation(pie));	847	QAbstractSeriesPrivate::initializeGraphics(parent);
849	presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));	848	}
850	return pie;	849
		850	void QPieSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
		851	{
		852	PieChartItem item = static_cast<PieChartItem >(m_item.data());
		853	Q_ASSERT(item);
		854	if (options.testFlag(QChart::SeriesAnimations)) {
		855	item->setAnimation(new PieAnimation(item));
		856	}else{
		857	item->setAnimation(0);
		858	}
		859	QAbstractSeriesPrivate::initializeAnimations(options);
851	}	860	}
852		861
853	QList<QLegendMarker> QPieSeriesPrivate::createLegendMarkers(QLegend legend)	862	QList<QLegendMarker> QPieSeriesPrivate::createLegendMarkers(QLegend legend)
@@ -861,9 +870,9 QList<QLegendMarker> QPieSeriesPrivate::createLegendMarkers(QLegend legend)
861	return markers;	870	return markers;
862	}	871	}
863		872
864	void QPieSeriesPrivate::initializeAxis(~~QAbstractAxis~~ *~~axis~~)	873	void QPieSeriesPrivate::initializeAxes()
865	{	874	{
866	Q_UNUSED(axis);	875
867	}	876	}
868		877
869	QAbstractAxis::AxisType QPieSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const	878	QAbstractAxis::AxisType QPieSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
@@ -872,6 +881,44 QAbstractAxis::AxisType QPieSeriesPrivate::defaultAxisType(Qt::Orientation orien
872	return QAbstractAxis::AxisTypeNoAxis;	881	return QAbstractAxis::AxisTypeNoAxis;
873	}	882	}
874		883
		884	QAbstractAxis* QPieSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
		885	{
		886	Q_UNUSED(orientation);
		887	return 0;
		888	}
		889
		890	void QPieSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
		891	{
		892	Q_Q(QPieSeries);
		893	const QList<QColor>& colors = theme->seriesColors();
		894	const QList<QGradient>& gradients = theme->seriesGradients();
		895
		896	for (int i(0); i < m_slices.count(); i++) {
		897
		898	QColor penColor = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0);
		899
		900	// Get color for a slice from a gradient linearly, beginning from the start of the gradient
		901	qreal pos = (qreal)(i + 1) / (qreal) m_slices.count();
		902	QColor brushColor = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), pos);
		903
		904	QPieSlice *s = m_slices.at(i);
		905	QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
		906
		907	if (forced \|\| d->m_data.m_slicePen.isThemed())
		908	d->setPen(penColor, true);
		909
		910	if (forced \|\| d->m_data.m_sliceBrush.isThemed())
		911	d->setBrush(brushColor, true);
		912
		913	if (forced \|\| d->m_data.m_labelBrush.isThemed())
		914	d->setLabelBrush(theme->labelBrush().color(), true);
		915
		916	if (forced \|\| d->m_data.m_labelFont.isThemed())
		917	d->setLabelFont(theme->labelFont(), true);
		918	}
		919	}
		920
		921
875	#include "moc_qpieseries.cpp"	922	#include "moc_qpieseries.cpp"
876	#include "moc_qpieseries_p.cpp"	923	#include "moc_qpieseries_p.cpp"
877		924

src/piechart/qpieseries.h +1 0

             private:
                 Q_DECLARE_PRIVATE(QPieSeries)
                 Q_DISABLE_COPY(QPieSeries)
+                friend class PieChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries_p.h +9 -4

                 QPieSeriesPrivate(QPieSeries *parent);
                 ~QPieSeriesPrivate();
-                void scaleDomain(Domain &domain);
+                void initializeDomain();
-                ChartElement *createGraphics(ChartPresenter *presenter);
+                void initializeAxes();
+                void initializeGraphics(QGraphicsItem* parent);
+                void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
+                void initializeTheme(int index, ChartTheme* theme, bool forced = false);
                 QList<QLegendMarker *> createLegendMarkers(QLegend *legend);
-                void initializeAxis(QAbstractAxis *axis);
                 QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const;
+                QAbstractAxis* createDefaultAxis(Qt::Orientation orientation) const;
                 void updateDerivativeData();
                 void setSizes(qreal innerSize, qreal outerSize);
                 qreal m_sum;
                 qreal m_holeRelativeSize;
-            private:
+            public:
                 friend class QLegendPrivate;
                 Q_DECLARE_PUBLIC(QPieSeries)
             };

src/piechart/qpieslice_p.h +1 -1

             private:
                 friend class QPieSeries;
                 friend class QPieSeriesPrivate;
-                friend class ChartTheme;
+                friend class ChartThemeManager;
                 friend class PieChartItem;
                 QPieSlice * const q_ptr;

src/qabstractseries.cpp +57 -2

@@ -21,6 +21,9
21	#include "qabstractseries.h"	21	#include "qabstractseries.h"
22	#include "qabstractseries_p.h"	22	#include "qabstractseries_p.h"
23	#include "chartdataset_p.h"	23	#include "chartdataset_p.h"
		24	#include "qchart.h"
		25	#include "qchart_p.h"
		26	#include "chartitem_p.h"
24		27
25	QTCOMMERCIALCHART_BEGIN_NAMESPACE	28	QTCOMMERCIALCHART_BEGIN_NAMESPACE
26		29
@@ -137,7 +140,7 QAbstractSeries::QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent) :
137	*/	140	*/
138	QAbstractSeries::~QAbstractSeries()	141	QAbstractSeries::~QAbstractSeries()
139	{	142	{
140	if (d_ptr->m_~~datase~~t)	143	if (d_ptr->m_chart)
141	qFatal("Still binded series detected !");	144	qFatal("Still binded series detected !");
142	}	145	}
143		146
@@ -222,12 +225,39 void QAbstractSeries::hide()
222	setVisible(false);	225	setVisible(false);
223	}	226	}
224		227
		228	bool QAbstractSeries::attachAxis(QAbstractAxis* axis)
		229	{
		230	if(d_ptr->m_chart) {
		231	return d_ptr->m_chart->d_ptr->m_dataset->attachAxis(this,axis);
		232	} else {
		233	qWarning()<<"Series not in the chart. Please addSeries to chart first.";
		234	return false;
		235	}
		236	}
		237
		238	bool QAbstractSeries::detachAxis(QAbstractAxis* axis)
		239	{
		240	if(d_ptr->m_chart) {
		241	return d_ptr->m_chart->d_ptr->m_dataset->detachAxis(this,axis);
		242	}
		243	else {
		244	qWarning()<<"Series not in the chart. Please addSeries to chart first.";
		245	return false;
		246	}
		247	}
		248
		249	QList<QAbstractAxis*> QAbstractSeries::attachedAxes()
		250	{
		251	return d_ptr->m_axes;
		252	}
		253
225	///////////////////////////////////////////////////////////////////////////////////////////////////	254	///////////////////////////////////////////////////////////////////////////////////////////////////
226		255
227	QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries *q)	256	QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries *q)
228	: q_ptr(q),	257	: q_ptr(q),
229	m_chart(0),	258	m_chart(0),
230	m_~~dataset~~(0),	259	m_item(0),
		260	m_domain(new Domain()),
231	m_visible(true),	261	m_visible(true),
232	m_opacity(1.0)	262	m_opacity(1.0)
233	{	263	{
@@ -237,6 +267,31 QAbstractSeriesPrivate::~QAbstractSeriesPrivate()
237	{	267	{
238	}	268	}
239		269
		270	void QAbstractSeriesPrivate::setDomain(QSharedPointer<Domain> domain)
		271	{
		272	Q_ASSERT(!domain.isNull());
		273	if(m_domain!=domain) {
		274	if(!m_item.isNull()) QObject::disconnect(m_domain.data(), SIGNAL(updated()), m_item.data(), SLOT(handleDomainUpdated()));
		275	m_domain = domain;
		276	if(!m_item.isNull()) {
		277	QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
		278	m_item->handleDomainUpdated();
		279	}
		280	}
		281	}
		282
		283	void QAbstractSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
		284	{
		285	Q_ASSERT(!m_item.isNull());
		286	Q_UNUSED(parent);
		287	QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
		288	}
		289
		290	void QAbstractSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
		291	{
		292	Q_UNUSED(options);
		293	}
		294
240	#include "moc_qabstractseries.cpp"	295	#include "moc_qabstractseries.cpp"
241	#include "moc_qabstractseries_p.cpp"	296	#include "moc_qabstractseries_p.cpp"
242		297

src/qabstractseries.h +5 0

                 QChart *chart() const;
+                bool attachAxis(QAbstractAxis* axis);
+                bool detachAxis(QAbstractAxis* axis);
+                QList<QAbstractAxis*> attachedAxes();
                 void show();
                 void hide();
                 QScopedPointer<QAbstractSeriesPrivate> d_ptr;
                 friend class ChartDataSet;
                 friend class ChartPresenter;
+                friend class ChartThemeManager;
                 friend class QLegendPrivate;
                 friend class DeclarativeChart;
             };

src/qabstractseries_p.h +27 -5

             #define QABSTRACTSERIES_P_H
             #include "qabstractseries.h"
+            #include "qchart.h"
+            #include "domain_p.h"
+            class QGraphicsItem;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class Domain;
             class ChartPresenter;
             class ChartElement;
             class LegendMarker;
             class ChartDataSet;
             class QAbstractAxis;
             class QLegendMarker;
+            class ChartTheme;
+            class ChartAnimation;
+            class ChartItem;
             class QAbstractSeriesPrivate : public QObject
             {
                 QAbstractSeriesPrivate(QAbstractSeries *q);
                 ~QAbstractSeriesPrivate();
-                virtual void scaleDomain(Domain &domain) = 0;
+                virtual void initializeDomain() = 0;
-                virtual ChartElement *createGraphics(ChartPresenter *presenter) = 0;
+                virtual void initializeAxes() = 0;
+                virtual void initializeTheme(int index, ChartTheme* theme, bool forced = false) = 0;
+                virtual void initializeGraphics(QGraphicsItem* parent) = 0;
+                virtual void initializeAnimations(QChart::AnimationOptions options) = 0;
                 virtual QList<QLegendMarker*> createLegendMarkers(QLegend* legend) = 0;
-                virtual void initializeAxis(QAbstractAxis *axis) = 0;
                 virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation) const = 0;
+                virtual QAbstractAxis* createDefaultAxis(Qt::Orientation) const = 0;
+                ChartItem* chartItem() { return m_item.data(); }
+                virtual void setDomain(QSharedPointer<Domain> domain);
+                QSharedPointer<Domain> domain() { return m_domain; }
+                QChart* chart() { return m_chart; }
             Q_SIGNALS:
                 void countChanged();
             protected:
                 QAbstractSeries *q_ptr;
                 QChart *m_chart;
-                ChartDataSet *m_dataset;
+                QScopedPointer<ChartItem> m_item;
+                QList<QAbstractAxis*> m_axes;
+            private:
+                QSharedPointer<Domain> m_domain;
                 QString m_name;
                 bool m_visible;
                 qreal m_opacity;
                 friend class QAbstractSeries;
                 friend class ChartDataSet;
+                friend class ChartPresenter;
                 friend class QLegendPrivate;
             };

src/qchart.cpp +174 -38

@@ -25,6 +25,9
25	#include "chartbackground_p.h"	25	#include "chartbackground_p.h"
26	#include "qabstractaxis.h"	26	#include "qabstractaxis.h"
27	#include "chartlayout_p.h"	27	#include "chartlayout_p.h"
		28	#include "charttheme_p.h"
		29	#include "chartpresenter_p.h"
		30	#include "chartdataset_p.h"
28	#include <QGraphicsScene>	31	#include <QGraphicsScene>
29	#include <QGraphicsSceneResizeEvent>	32	#include <QGraphicsSceneResizeEvent>
30		33
@@ -106,13 +109,11 QTCOMMERCIALCHART_BEGIN_NAMESPACE
106	*/	109	*/
107	QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)	110	QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
108	: QGraphicsWidget(parent, wFlags),	111	: QGraphicsWidget(parent, wFlags),
109	d_ptr(new QChartPrivate())	112	d_ptr(new QChartPrivate(this))
110	{	113	{
111	d_ptr->m_dataset = new ChartDataSet(this);
112	d_ptr->m_presenter = new ChartPresenter(this, d_ptr->m_dataset);
113	d_ptr->createConnections();
114	d_ptr->m_legend = new LegendScroller(this);	114	d_ptr->m_legend = new LegendScroller(this);
115	~~d_ptr~~->~~m_presenter~~->setTheme(QChart::ChartThemeLight, ~~false~~);	115	setTheme(QChart::ChartThemeLight);
		116	//TODO: what is that ?
116	//connect(d_ptr->m_presenter, SIGNAL(marginsChanged(QRectF)), this, SIGNAL(marginsChanged(QRectF)));	117	//connect(d_ptr->m_presenter, SIGNAL(marginsChanged(QRectF)), this, SIGNAL(marginsChanged(QRectF)));
117	setLayout(d_ptr->m_presenter->layout());	118	setLayout(d_ptr->m_presenter->layout());
118	}	119	}
@@ -122,10 +123,9 QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
122	*/	123	*/
123	QChart::~QChart()	124	QChart::~QChart()
124	{	125	{
125	//delete first presenter , since this is a root of all the graphical items	126	//start by deleting dataset, it will remove all series and axes
126	setLayout(0);	127	delete d_ptr->m_dataset;
127	~~delete~~ d_ptr->m_~~presenter~~;	128	d_ptr->m_dataset = 0;
128	d_ptr->m_presenter = 0;
129	}	129	}
130		130
131	/*!	131	/*!
@@ -245,12 +245,12 QBrush QChart::titleBrush() const
245		245
246	void QChart::setTheme(QChart::ChartTheme theme)	246	void QChart::setTheme(QChart::ChartTheme theme)
247	{	247	{
248	d_ptr->m_~~present~~er->setTheme(theme);	248	d_ptr->m_themeManager->setTheme(theme);
249	}	249	}
250		250
251	QChart::ChartTheme QChart::theme() const	251	QChart::ChartTheme QChart::theme() const
252	{	252	{
253	return d_ptr->m_~~present~~er->theme();	253	return d_ptr->m_themeManager->theme()->id();
254	}	254	}
255		255
256	/*!	256	/*!
@@ -258,7 +258,7 QChart::ChartTheme QChart::theme() const
258	*/	258	*/
259	void QChart::zoomIn()	259	void QChart::zoomIn()
260	{	260	{
261	d_ptr->~~m_presenter~~->zoomIn(2.0);	261	d_ptr->zoomIn(2.0);
262	}	262	}
263		263
264	/*!	264	/*!
@@ -266,9 +266,7 void QChart::zoomIn()
266	*/	266	*/
267	void QChart::zoomIn(const QRectF &rect)	267	void QChart::zoomIn(const QRectF &rect)
268	{	268	{
269	if (!rect.isValid())	269	d_ptr->zoomIn(rect);
270	return;
271	d_ptr->m_presenter->zoomIn(rect);
272	}	270	}
273		271
274	/*!	272	/*!
@@ -276,7 +274,7 void QChart::zoomIn(const QRectF &rect)
276	*/	274	*/
277	void QChart::zoomOut()	275	void QChart::zoomOut()
278	{	276	{
279	d_ptr->~~m_presenter~~->zoomOut(2.0);	277	d_ptr->zoomOut(2.0);
280	}	278	}
281		279
282	/*!	280	/*!
@@ -296,9 +294,9 void QChart::zoom(qreal factor)
296	return;	294	return;
297		295
298	if (factor > 1.0)	296	if (factor > 1.0)
299	d_ptr->~~m_presenter~~->zoomIn(factor);	297	d_ptr->zoomIn(factor);
300	else	298	else
301	d_ptr->~~m_presenter~~->zoomOut(1.0 / factor);	299	d_ptr->zoomOut(1.0 / factor);
302	}	300	}
303		301
304	/*!	302	/*!
@@ -307,7 +305,27 void QChart::zoom(qreal factor)
307	*/	305	*/
308	QAbstractAxis QChart::axisX(QAbstractSeries series) const	306	QAbstractAxis QChart::axisX(QAbstractSeries series) const
309	{	307	{
310	~~return~~ d_ptr->m_dataset->~~axisX~~(~~series~~);	308	if(!series && d_ptr->m_dataset->series().size()>0){
		309	series = d_ptr->m_dataset->series().first();
		310	}else{
		311	return 0;
		312	}
		313
		314	QList<QAbstractAxis*> axes = series->attachedAxes();
		315	QAbstractAxis* bottom=0;
		316	QAbstractAxis* top=0;
		317
		318	foreach(QAbstractAxis* axis, axes){
		319
		320	if(axis->alignment()==Qt::AlignTop){
		321	top=axis;
		322	}
		323
		324	if(axis->alignment()==Qt::AlignBottom){
		325	bottom=axis;
		326	}
		327	}
		328	return bottom?bottom:top;
311	}	329	}
312		330
313	/*!	331	/*!
@@ -316,7 +334,42 QAbstractAxis QChart::axisX(QAbstractSeries series) const
316	*/	334	*/
317	QAbstractAxis QChart::axisY(QAbstractSeries series) const	335	QAbstractAxis QChart::axisY(QAbstractSeries series) const
318	{	336	{
319	~~return~~ d_ptr->m_dataset->~~axisY~~(~~series~~);	337	if(!series && d_ptr->m_dataset->series().size()>0) {
		338	series = d_ptr->m_dataset->series().first();
		339	} else {
		340	return 0;
		341	}
		342
		343	QList<QAbstractAxis*> axes = series->attachedAxes();
		344
		345	QAbstractAxis* left=0;
		346	QAbstractAxis* right=0;
		347
		348	foreach(QAbstractAxis* axis, axes){
		349
		350	if(axis->alignment()==Qt::AlignLeft){
		351	left=axis;
		352	}
		353
		354	if(axis->alignment()==Qt::AlignRight){
		355	right=axis;
		356	}
		357	}
		358
		359	return left?left:right;
		360	}
		361
		362
		363	QList<QAbstractAxis > QChart::axes(Qt::Orientations orientation, QAbstractSeries series) const
		364	{
		365	QList<QAbstractAxis *> result ;
		366
		367	foreach(QAbstractAxis* axis,series->attachedAxes()){
		368	if(orientation.testFlag(axis->orientation()))
		369	result << axis;
		370	}
		371
		372	return result;
320	}	373	}
321		374
322	/*!	375	/*!
@@ -410,7 +463,7 QMargins QChart::margins() const
410	*/	463	*/
411	QRectF QChart::plotArea() const	464	QRectF QChart::plotArea() const
412	{	465	{
413	return d_ptr->m_presenter->~~layout~~()->~~chartsG~~eometry();	466	return d_ptr->m_presenter->geometry();
414	}	467	}
415		468
416	///*!	469	///*!
@@ -440,7 +493,7 QChart::AnimationOptions QChart::animationOptions() const
440	*/	493	*/
441	void QChart::scroll(qreal dx, qreal dy)	494	void QChart::scroll(qreal dx, qreal dy)
442	{	495	{
443	d_ptr->~~m_presenter~~->scroll(dx, dy);	496	d_ptr->scroll(dx,dy);
444	}	497	}
445		498
446	void QChart::setBackgroundVisible(bool visible)	499	void QChart::setBackgroundVisible(bool visible)
@@ -480,9 +533,18 QList<QAbstractSeries *> QChart::series() const
480	*/	533	*/
481	void QChart::setAxisX(QAbstractAxis axis , QAbstractSeries series)	534	void QChart::setAxisX(QAbstractAxis axis , QAbstractSeries series)
482	{	535	{
483	if (axis->alignment() == Qt::AlignLeft \|\| axis->alignment() == Qt::AlignRight)	536	QList<QAbstractAxis*> list = axes(Qt::Horizontal,series);
484	return;	537
485	d_ptr->m_dataset->setAxis(series, axis, Qt::Horizontal);	538	foreach(QAbstractAxis* a, list){
		539	if(a->alignment()==axis->alignment()){
		540	d_ptr->m_dataset->removeAxis(a);
		541	delete a;
		542	}
		543	}
		544
		545	if(!d_ptr->m_dataset->axes().contains(axis))
		546	d_ptr->m_dataset->addAxis(axis,Qt::AlignBottom);
		547	d_ptr->m_dataset->attachAxis(series,axis);
486	}	548	}
487		549
488	/*!	550	/*!
@@ -492,19 +554,47 void QChart::setAxisX(QAbstractAxis axis , QAbstractSeries series)
492	*/	554	*/
493	void QChart::setAxisY(QAbstractAxis axis , QAbstractSeries series)	555	void QChart::setAxisY(QAbstractAxis axis , QAbstractSeries series)
494	{	556	{
495	if (axis->alignment() == Qt::AlignTop \|\| axis->alignment() == Qt::AlignBottom)	557	QList<QAbstractAxis*> list = axes(Qt::Vertical,series);
496	return;	558
497	d_ptr->m_dataset->setAxis(series, axis, Qt::Vertical);	559	foreach(QAbstractAxis* a, list) {
		560	if(a->alignment()==axis->alignment()) {
		561	d_ptr->m_dataset->removeAxis(a);
		562	delete a;
		563	}
		564	}
		565
		566	if(!d_ptr->m_dataset->axes().contains(axis))
		567	d_ptr->m_dataset->addAxis(axis,Qt::AlignLeft);
		568	d_ptr->m_dataset->attachAxis(series,axis);
		569	}
		570
		571	void QChart::addAxis(QAbstractAxis *axis,Qt::Alignment aligment)
		572	{
		573	d_ptr->m_dataset->addAxis(axis,aligment);
		574	}
		575
		576	void QChart::removeAxis(QAbstractAxis *axis)
		577	{
		578	d_ptr->m_dataset->removeAxis(axis);
498	}	579	}
499		580
500	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	581	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
501		582
502	QChartPrivate::QChartPrivate():	583	QChartPrivate::QChartPrivate(QChart *q):
		584	q_ptr(q),
503	m_legend(0),	585	m_legend(0),
504	m_dataset(0),	586	m_dataset(new ChartDataSet(q)),
505	m_presenter(0)	587	m_presenter(new ChartPresenter(q)),
		588	m_themeManager(new ChartThemeManager(q))
506	{	589	{
507		590	QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries)), m_presenter, SLOT(handleSeriesAdded(QAbstractSeries)));
		591	QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries)), m_presenter, SLOT(handleSeriesRemoved(QAbstractSeries)));
		592	QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis)), m_presenter, SLOT(handleAxisAdded(QAbstractAxis)));
		593	QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis)), m_presenter, SLOT(handleAxisRemoved(QAbstractAxis)));
		594	QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries)), m_themeManager, SLOT(handleSeriesAdded(QAbstractSeries)));
		595	QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries)), m_themeManager, SLOT(handleSeriesRemoved(QAbstractSeries)));
		596	QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis)), m_themeManager, SLOT(handleAxisAdded(QAbstractAxis)));
		597	QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis)), m_themeManager, SLOT(handleAxisRemoved(QAbstractAxis)));
508	}	598	}
509		599
510	QChartPrivate::~QChartPrivate()	600	QChartPrivate::~QChartPrivate()
@@ -512,13 +602,59 QChartPrivate::~QChartPrivate()
512		602
513	}	603	}
514		604
515	void QChartPrivate::~~createConnections~~()	605	void QChartPrivate::zoomIn(qreal factor)
516	{	606	{
517	QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries,Domain)), m_presenter, SLOT(handleSeriesAdded(QAbstractSeries,Domain)));	607	QRectF rect = m_presenter->geometry();
518	QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries)), m_presenter, SLOT(handleSeriesRemoved(QAbstractSeries)));	608	rect.setWidth(rect.width() / factor);
519	QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis,Domain)), m_presenter, SLOT(handleAxisAdded(QAbstractAxis,Domain)));	609	rect.setHeight(rect.height() / factor);
520	QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis)), m_presenter, SLOT(handleAxisRemoved(QAbstractAxis)));	610	rect.moveCenter(m_presenter->geometry().center());
521	//QObject::connect(m_presenter, SIGNAL(marginsChanged(QRectF)), q_ptr, SIGNAL(marginsChanged(QRectF)));	611	zoomIn(rect);
		612	}
		613
		614	void QChartPrivate::zoomIn(const QRectF &rect)
		615	{
		616	if (!rect.isValid())
		617	return;
		618
		619	QRectF r = rect.normalized();
		620	const QRectF geometry = m_presenter->geometry();
		621	r.translate(-geometry.topLeft());
		622
		623	if (!r.isValid())
		624	return;
		625
		626	QPointF zoomPoint(r.center().x() / geometry.width(), r.center().y() / geometry.height());
		627	m_presenter->setState(ChartPresenter::ZoomInState,zoomPoint);
		628	m_dataset->zoomInDomain(r);
		629	m_presenter->setState(ChartPresenter::ShowState,QPointF());
		630
		631	}
		632
		633	void QChartPrivate::zoomOut(qreal factor)
		634	{
		635	const QRectF geometry = m_presenter->geometry();
		636
		637	QRectF r;
		638	r.setSize(geometry.size() / factor);
		639	r.moveCenter(QPointF(geometry.size().width()/2 ,geometry.size().height()/2));
		640	if (!r.isValid())
		641	return;
		642
		643	QPointF zoomPoint(r.center().x() / geometry.width(), r.center().y() / geometry.height());
		644	m_presenter->setState(ChartPresenter::ZoomOutState,zoomPoint);
		645	m_dataset->zoomOutDomain(r);
		646	m_presenter->setState(ChartPresenter::ShowState,QPointF());
		647	}
		648
		649	void QChartPrivate::scroll(qreal dx, qreal dy)
		650	{
		651	if (dx < 0) m_presenter->setState(ChartPresenter::ScrollLeftState,QPointF());
		652	if (dx > 0) m_presenter->setState(ChartPresenter::ScrollRightState,QPointF());
		653	if (dy < 0) m_presenter->setState(ChartPresenter::ScrollUpState,QPointF());
		654	if (dy > 0) m_presenter->setState(ChartPresenter::ScrollDownState,QPointF());
		655
		656	m_dataset->scrollDomain(dx, dy);
		657	m_presenter->setState(ChartPresenter::ShowState,QPointF());
522	}	658	}
523		659
524	#include "moc_qchart.cpp"	660	#include "moc_qchart.cpp"

src/qchart.h +13 -1

                 void removeAllSeries();
                 QList<QAbstractSeries *> series() const;
+                //depreciated shit//////////////////////////////////////////////////.
                 void setAxisX(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 void setAxisY(QAbstractAxis *axis, QAbstractSeries *series = 0);
                 QAbstractAxis *axisX(QAbstractSeries *series = 0) const;
                 QAbstractAxis *axisY(QAbstractSeries *series = 0) const;
+                /////////////////////////////////////////////////////////////////////
+                void addAxis(QAbstractAxis *axis,Qt::Alignment aligment);
+                void removeAxis(QAbstractAxis *axis);
+                QList<QAbstractAxis*> axes(Qt::Orientations orientation = Qt::Horizontal|Qt::Vertical, QAbstractSeries *series = 0) const;
                 void createDefaultAxes();
                 AnimationOptions animationOptions() const;
                 void zoomIn();
-                void zoomIn(const QRectF &rect);
                 void zoomOut();
+                void zoomIn(const QRectF &rect);
                 void zoom(qreal factor);
                 void scroll(qreal dx, qreal dy);
                 QLegend *legend() const;
                 QScopedPointer<QChartPrivate> d_ptr;
                 friend class QLegend;
                 friend class DeclarativeChart;
+                friend class ChartDataSet;
+                friend class ChartPresenter;
+                friend class ChartThemeManager;
+                friend class QAbstractSeries;
                 Q_DISABLE_COPY(QChart)
             };

src/qchart_p.h +15 -6

             #ifndef QCHART_P_H
             #define QCHART_P_H
-            #include "qlegend.h"
+            #include "qchartglobal.h"
-            #include "chartpresenter_p.h"
-            #include "chartdataset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
+            class ChartThemeManager;
+            class ChartPresenter;
+            class QLegend;
+            class ChartDataSet;
-            struct QChartPrivate
+            class QChartPrivate
             {
-                QChartPrivate();
+            public:
+                QChartPrivate(QChart *q);
                 ~QChartPrivate();
+                QChart *q_ptr;
                 QLegend *m_legend;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;
+                ChartThemeManager *m_themeManager;
-                void createConnections();
+                void zoomIn(qreal factor);
+                void zoomOut(qreal factor);
+                void zoomIn(const QRectF &rect);
+                void scroll(qreal dx, qreal dy);
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterchart/qscatterseries.cpp +26 -8

@@ -143,8 +143,8 QScatterSeries::QScatterSeries(QObject *parent)
143	QScatterSeries::~QScatterSeries()	143	QScatterSeries::~QScatterSeries()
144	{	144	{
145	Q_D(QScatterSeries);	145	Q_D(QScatterSeries);
146	if (d->m_~~datase~~t)	146	if (d->m_chart)
147	d->m_~~datase~~t->removeSeries(this);	147	d->m_chart->removeSeries(this);
148	}	148	}
149		149
150	QAbstractSeries::SeriesType QScatterSeries::type() const	150	QAbstractSeries::SeriesType QScatterSeries::type() const
@@ -254,14 +254,32 QScatterSeriesPrivate::QScatterSeriesPrivate(QScatterSeries *q)
254	{	254	{
255	}	255	}
256		256
257	ChartElement QScatterSeriesPrivate::createGraphics(ChartPresenter presenter)	257	void QScatterSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
258	{	258	{
259	Q_Q(QScatterSeries);	259	Q_Q(QScatterSeries);
260	ScatterChartItem *scatter = new ScatterChartItem(q, presenter);	260	ScatterChartItem *scatter = new ScatterChartItem(q,parent);
261	if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))	261	m_item.reset(scatter);
262	scatter->setAnimation(new XYAnimation(scatter));	262	QAbstractSeriesPrivate::initializeGraphics(parent);
263	presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));	263	}
264	return scatter;	264
		265	void QScatterSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
		266	{
		267	Q_Q(QScatterSeries);
		268	QPen pen;
		269	QBrush brush;
		270	const QList<QColor> colors = theme->seriesColors();
		271	const QList<QGradient> gradients = theme->seriesGradients();
		272
		273	if (forced \|\| pen == m_pen) {
		274	pen.setColor(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0));
		275	pen.setWidthF(2);
		276	q->setPen(pen);
		277	}
		278
		279	if (forced \|\| brush == m_brush) {
		280	QBrush brush(colors.at(index % colors.size()));
		281	q->setBrush(brush);
		282	}
265	}	283	}
266		284
267	#include "moc_qscatterseries.cpp"	285	#include "moc_qscatterseries.cpp"

src/scatterchart/qscatterseries_p.h +2 -1

             {
             public:
                 QScatterSeriesPrivate(QScatterSeries *q);
-                ChartElement *createGraphics(ChartPresenter *presenter);
+                void initializeGraphics(QGraphicsItem* parent);
+                void initializeTheme(int index, ChartTheme* theme, bool forced = false);
             private:
                 QScatterSeries::MarkerShape m_shape;

src/scatterchart/scatterchartitem.cpp +9 -8

             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "chartpresenter_p.h"
+            #include "domain_p.h"
             #include <QPainter>
             #include <QGraphicsScene>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ScatterChartItem::ScatterChartItem(QScatterSeries *series, ChartPresenter *presenter)
+            ScatterChartItem::ScatterChartItem(QScatterSeries *series, QGraphicsItem* item)
-                : XYChart(series, presenter),
+                : XYChart(series,item),
-                  QGraphicsItem(presenter ? presenter->rootItem() : 0),
                   m_series(series),
                   m_items(this),
                   m_visible(true),
             void ScatterChartItem::markerSelected(QGraphicsItem *marker)
             {
-                emit XYChart::clicked(calculateDomainPoint(m_markerMap[marker]));
+                emit XYChart::clicked(domain()->calculateDomainPoint(m_markerMap[marker]));
             }
             void ScatterChartItem::markerHovered(QGraphicsItem *marker, bool state)
             {
-                emit XYChart::hovered(calculateDomainPoint(m_markerMap[marker]), state);
+                emit XYChart::hovered(domain()->calculateDomainPoint(m_markerMap[marker]), state);
             }
             void ScatterChartItem::updateGeometry()
                 QList<QGraphicsItem *> items = m_items.childItems();
+                QRectF clipRect(QPointF(0,0),domain()->size());
                 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;
                     item->setPos(point.x() - rect.width() / 2, point.y() - rect.height() / 2);
-                    if (!m_visible || !clipRect().contains(point))
+                    if (!m_visible || !clipRect.contains(point))
                         item->setVisible(false);
                     else
                         item->setVisible(true);
                 }
                 prepareGeometryChange();
-                m_rect = clipRect();
+                m_rect = clipRect;
-                setPos(origin());
             }
             void ScatterChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)

src/scatterchart/scatterchartitem_p.h +2 -2

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

src/splinechart/qsplineseries.cpp +32 -8

@@ -114,8 +114,8 QSplineSeries::QSplineSeries(QObject *parent)
114	QSplineSeries::~QSplineSeries()	114	QSplineSeries::~QSplineSeries()
115	{	115	{
116	Q_D(QSplineSeries);	116	Q_D(QSplineSeries);
117	if (d->m_~~datase~~t)	117	if (d->m_chart)
118	d->m_~~datase~~t->removeSeries(this);	118	d->m_chart->removeSeries(this);
119	}	119	}
120		120
121	QAbstractSeries::SeriesType QSplineSeries::type() const	121	QAbstractSeries::SeriesType QSplineSeries::type() const
@@ -244,14 +244,38 void QSplineSeriesPrivate::updateControlPoints()
244	}	244	}
245	}	245	}
246		246
247	ChartElement QSplineSeriesPrivate::createGraphics(ChartPresenter presenter)	247	void QSplineSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
248	{	248	{
249	Q_Q(QSplineSeries);	249	Q_Q(QSplineSeries);
250	SplineChartItem *spline = new SplineChartItem(q, presenter);	250	SplineChartItem *spline = new SplineChartItem(q,parent);
251	if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))	251	m_item.reset(spline);
252	spline->setAnimation(new SplineAnimation(spline));	252	QAbstractSeriesPrivate::initializeGraphics(parent);
253	presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));	253	}
254	return spline;	254
		255	void QSplineSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
		256	{
		257	Q_Q(QSplineSeries);
		258	const QList<QColor> colors = theme->seriesColors();
		259
		260	QPen pen;
		261	if (forced \|\| pen == m_pen) {
		262	pen.setColor(colors.at(index % colors.size()));
		263	pen.setWidthF(2);
		264	q->setPen(pen);
		265	}
		266	}
		267
		268
		269	void QSplineSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
		270	{
		271	SplineChartItem item = static_cast<SplineChartItem >(m_item.data());
		272	Q_ASSERT(item);
		273	if (options.testFlag(QChart::SeriesAnimations)) {
		274	item->setAnimation(new SplineAnimation(item));
		275	}else{
		276	item->setAnimation(0);
		277	}
		278	QAbstractSeriesPrivate::initializeAnimations(options);
255	}	279	}
256		280
257	#include "moc_qsplineseries.cpp"	281	#include "moc_qsplineseries.cpp"

src/splinechart/qsplineseries_p.h +4 -1

             {
                 Q_OBJECT
             public:
-                ChartElement *createGraphics(ChartPresenter *presenter);
                 QSplineSeriesPrivate(QSplineSeries *q);
+                void initializeTheme(int index, ChartTheme* theme, bool forced = false);
+                void initializeGraphics(QGraphicsItem* parent);
+                void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
                 QPointF controlPoint(int index) const;
             public Q_SLOTS:

src/splinechart/splinechartitem.cpp +9 -9

             #include "qsplineseries_p.h"
             #include "chartpresenter_p.h"
             #include "splineanimation_p.h"
+            #include "domain_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            SplineChartItem::SplineChartItem(QSplineSeries *series, ChartPresenter *presenter)
+            SplineChartItem::SplineChartItem(QSplineSeries *series, QGraphicsItem* item)
-                : XYChart(series, presenter),
+                : XYChart(series,item),
-                  QGraphicsItem(presenter ? presenter->rootItem() : 0),
                   m_series(series),
                   m_pointsVisible(false),
                   m_animation(0)
             QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
             {
-                return XYChart::calculateGeometryPoint(m_series->d_func()->controlPoint(index));
+                return domain()->calculateGeometryPoint(m_series->d_func()->controlPoint(index));
             }
             void SplineChartItem::updateGeometry()
                 //    m_path = stroker.createStroke(splinePath);
                 m_path = splinePath;
                 m_rect = splinePath.boundingRect();
-                setPos(origin());
             }
             //handlers
                 Q_UNUSED(option)
                 painter->save();
+                painter->setClipRect(QRectF(QPointF(0,0),domain()->size()));
                 painter->setPen(m_linePen);
                 //    painter->setBrush(m_linePen.color());
-                painter->setClipRect(clipRect());
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
             void SplineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
-                emit XYChart::clicked(calculateDomainPoint(event->pos()));
+                emit XYChart::clicked(domain()->calculateDomainPoint(event->pos()));
                 QGraphicsItem::mousePressEvent(event);
             }
             void SplineChartItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
-                emit XYChart::hovered(calculateDomainPoint(event->pos()), true);
+                emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), true);
                 event->accept();
             }
             void SplineChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
-                emit XYChart::hovered(calculateDomainPoint(event->pos()), false);
+                emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), false);
                 event->accept();
             }

src/splinechart/splinechartitem_p.h +2 -2

             class SplineAnimation;
-            class SplineChartItem : public XYChart, public QGraphicsItem
+            class SplineChartItem : public XYChart
             {
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsItem)
             public:
-                SplineChartItem(QSplineSeries *series, ChartPresenter *presenter);
+                SplineChartItem(QSplineSeries *series, QGraphicsItem* item = 0);
                 //from QGraphicsItem
                 QRectF boundingRect() const;

src/src.pro +3 -2

             SOURCES += \
                 $$PWD/chartdataset.cpp \
                 $$PWD/chartpresenter.cpp \
-                $$PWD/charttheme.cpp \
+                $$PWD/chartthememanager.cpp \
                 $$PWD/domain.cpp \
                 $$PWD/qchart.cpp \
                 $$PWD/qchartview.cpp \
                 $$PWD/qabstractseries.cpp \
                 $$PWD/chartbackground.cpp \
                 $$PWD/chartelement.cpp \
+                $$PWD/chartitem.cpp \
                 $$PWD/scroller.cpp \
                 $$PWD/chartlayout.cpp \
                 $$PWD/charttitle.cpp
                 $$PWD/chartdataset_p.h \
                 $$PWD/chartitem_p.h \
                 $$PWD/chartpresenter_p.h \
-                $$PWD/charttheme_p.h \
+                $$PWD/chartthememanager_p.h \
                 $$PWD/domain_p.h \
                 $$PWD/chartbackground_p.h \
                 $$PWD/chartelement_p.h \

src/themes/charttheme_p.h ~~src/charttheme_p.h~~ renamed +18 -39

@@ -30,33 +30,15
30	#ifndef CHARTTHEME_H	30	#ifndef CHARTTHEME_H
31	#define CHARTTHEME_H	31	#define CHARTTHEME_H
32		32
33	#include "~~qchartglobal~~.h"	33	#include "chartthememanager_p.h"
34	#include "qchart.h"
35	#include <QColor>	34	#include <QColor>
36	#include <QGradientStops>	35	#include <QGradientStops>
37		36
38	QTCOMMERCIALCHART_BEGIN_NAMESPACE	37	QTCOMMERCIALCHART_BEGIN_NAMESPACE
39		38
40	class ChartItem;
41	class LineChartItem;
42	class QLineSeries;
43	class AbstractBarChartItem;
44	class QAbstractBarSeries;
45	class StackedBarChartItem;
46	class QStackedBarSeries;
47	class QPercentBarSeries;
48	class PercentBarChartItem;
49	class QScatterSeries;
50	class ScatterChartItem;
51	class PieChartItem;
52	class QPieSeries;
53	class SplineChartItem;
54	class QSplineSeries;
55	class AreaChartItem;
56	class QAreaSeries;
57
58	class ChartTheme	39	class ChartTheme
59	{	40	{
		41
60	public:	42	public:
61	enum BackgroundShadesMode {	43	enum BackgroundShadesMode {
62	BackgroundShadesNone = 0,	44	BackgroundShadesNone = 0,
@@ -66,26 +48,23 public:
66	};	48	};
67		49
68	protected:	50	protected:
69	explicit ChartTheme(QChart::ChartTheme id = QChart::ChartThemeLight);	51	explicit ChartTheme(QChart::ChartTheme id = QChart::ChartThemeLight):m_id(id),
		52	m_backgroundShades(BackgroundShadesNone),
		53	m_backgroundDropShadowEnabled(false){};
70	public:	54	public:
71	static ChartTheme *createTheme(QChart::ChartTheme theme);
72	QChart::ChartTheme id() const { return m_id; }	55	QChart::ChartTheme id() const { return m_id; }
73	void decorate(QChart *chart);	56	QList<QGradient> seriesGradients() const { return m_seriesGradients; }
74	void decorate(QLegend *legend);	57	QList<QColor> seriesColors() const { return m_seriesColors; }
75	void decorate(QAbstractBarSeries *series, int index);	58	QLinearGradient chartBackgroundGradient() const { return m_chartBackgroundGradient; }
76	void decorate(QLineSeries *series, int index);	59	QFont masterFont() const { return m_masterFont; }
77	void decorate(QAreaSeries *series, int index);	60	QFont labelFont() const { return m_labelFont; }
78	void decorate(QScatterSeries *series, int index);	61	QBrush labelBrush() const { return m_labelBrush; }
79	void decorate(QPieSeries *series, int index);	62	QPen axisLinePen() const { return m_axisLinePen; }
80	void decorate(QSplineSeries *series, int index);	63	QPen backgroundShadesPen() const { return m_backgroundShadesPen; }
81	void decorate(QAbstractAxis *axis);	64	QBrush backgroundShadesBrush() const { return m_backgroundShadesBrush; }
82	void setForced(bool enabled);	65	BackgroundShadesMode backgroundShades() const { return m_backgroundShades; }
83	bool isForced() { return m_force; }	66	bool isBackgroundDropShadowEnabled() const { return m_backgroundDropShadowEnabled; }
84		67	QPen girdLinePen() const { return m_gridLinePen; }
85	public: // utils
86	void generateSeriesGradients();
87	static QColor colorAt(const QColor &start, const QColor &end, qreal pos);
88	static QColor colorAt(const QGradient &gradient, qreal pos);
89		68
90	protected:	69	protected:
91	QChart::ChartTheme m_id;	70	QChart::ChartTheme m_id;
@@ -102,7 +81,7 protected:
102	BackgroundShadesMode m_backgroundShades;	81	BackgroundShadesMode m_backgroundShades;
103	bool m_backgroundDropShadowEnabled;	82	bool m_backgroundDropShadowEnabled;
104	QPen m_gridLinePen;	83	QPen m_gridLinePen;
105	bool m_force;	84
106	};	85	};
107		86
108	QTCOMMERCIALCHART_END_NAMESPACE	87	QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemebluecerulean_p.h +1 -1

                     m_seriesColors << QRgb(0x5cbf9b);
                     m_seriesColors << QRgb(0x009fbf);
                     m_seriesColors << QRgb(0xee7392);
-                    generateSeriesGradients();
+                    m_seriesGradients = ChartThemeManager::generateSeriesGradients(m_seriesColors);
                     // Background
                     QLinearGradient backgroundGradient(0.5, 0.0, 0.5, 1.0);

src/themes/chartthemeblueicy_p.h +1 -1

                     m_seriesColors << QRgb(0x0c2673);
                     m_seriesColors << QRgb(0x5f3dba);
                     m_seriesColors << QRgb(0x2fa3b4);
-                    generateSeriesGradients();
+                    m_seriesGradients = ChartThemeManager::generateSeriesGradients(m_seriesColors);
                     // Background
                     QLinearGradient backgroundGradient(0.5, 0.0, 0.5, 1.0);

src/themes/chartthemebluencs_p.h +1 -1

                     m_seriesColors << QRgb(0x88d41e);
                     m_seriesColors << QRgb(0xff8e1a);
                     m_seriesColors << QRgb(0x398ca3);
-                    generateSeriesGradients();
+                    m_seriesGradients = ChartThemeManager::generateSeriesGradients(m_seriesColors);
                     // Background
                     QLinearGradient backgroundGradient;

src/themes/chartthemebrownsand_p.h +1 -1

                     m_seriesColors << QRgb(0xc35660);
                     m_seriesColors << QRgb(0x536780);
                     m_seriesColors << QRgb(0x494345);
-                    generateSeriesGradients();
+                    m_seriesGradients = ChartThemeManager::generateSeriesGradients(m_seriesColors);
                     // Background
                     QLinearGradient backgroundGradient;

src/themes/chartthemedark_p.h +1 -1

                     m_seriesColors << QRgb(0xeb8817);
                     m_seriesColors << QRgb(0x7b7f8c);
                     m_seriesColors << QRgb(0xbf593e);
-                    generateSeriesGradients();
+                    m_seriesGradients = ChartThemeManager::generateSeriesGradients(m_seriesColors);
                     // Background
                     QLinearGradient backgroundGradient(0.5, 0.0, 0.5, 1.0);

src/themes/chartthemehighcontrast_p.h +1 -1

                     m_seriesColors << QRgb(0xffab03);
                     m_seriesColors << QRgb(0x038e9b);
                     m_seriesColors << QRgb(0xff4a41);
-                    generateSeriesGradients();
+                    m_seriesGradients = ChartThemeManager::generateSeriesGradients(m_seriesColors);
                     // Background
                     QLinearGradient backgroundGradient(0.5, 0.0, 0.5, 1.0);

src/themes/chartthemelight_p.h +1 -1

                     m_seriesColors << QRgb(0xf6a625);
                     m_seriesColors << QRgb(0x6d5fd5);
                     m_seriesColors << QRgb(0xbf593e);
-                    generateSeriesGradients();
+                    m_seriesGradients = ChartThemeManager::generateSeriesGradients(m_seriesColors);
                     // Background
                     QLinearGradient backgroundGradient;

src/themes/chartthemesystem_p.h +2 -2

                     m_seriesColors << QRgb(0x92ca66);
                     m_seriesColors << QRgb(0xeba85f);
                     m_seriesColors << QRgb(0xfc5751);
-                    generateSeriesGradients();
+                    m_seriesGradients = ChartThemeManager::generateSeriesGradients(m_seriesColors);
                     // Background
                     QLinearGradient backgroundGradient;
                     m_seriesColors << QRgb(0x92ca66);
                     m_seriesColors << QRgb(0xeba85f);
                     m_seriesColors << QRgb(0xfc5751);
-                    generateSeriesGradients();
+                    m_seriesGradients = ChartThemeManager::generateSeriesGradients(m_seriesColors);
                     // Background
                     QLinearGradient backgroundGradient;

src/themes/themes.pri +1 0

             DEPENDPATH += $$PWD
             THEMES += \
+                $$PWD/charttheme_p.h \
                 $$PWD/chartthemesystem_p.h \
                 $$PWD/chartthemelight_p.h \
                 $$PWD/chartthemebluecerulean_p.h \

src/xychart/qxyseries.cpp +23 -4

             #include "qxyseries_p.h"
             #include "domain_p.h"
             #include "qvalueaxis.h"
+            #include "xychart_p.h"
             #include "qxylegendmarker.h"
             {
             }
-            void QXYSeriesPrivate::scaleDomain(Domain &domain)
+            void QXYSeriesPrivate::initializeDomain()
             {
                 qreal minX(0);
                 qreal minY(0);
                     }
                 }
-                domain.setRange(minX, maxX, minY, maxY);
+                domain()->setRange(minX, maxX, minY, maxY);
             }
             QList<QLegendMarker*> QXYSeriesPrivate::createLegendMarkers(QLegend* legend)
                 return list << new QXYLegendMarker(q,legend);
             }
-            void QXYSeriesPrivate::initializeAxis(QAbstractAxis *axis)
+            void QXYSeriesPrivate::initializeAxes()
             {
-                Q_UNUSED(axis);
             }
             QAbstractAxis::AxisType QXYSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
                 return QAbstractAxis::AxisTypeValue;
             }
+            QAbstractAxis* QXYSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
+            {
+                Q_UNUSED(orientation);
+                return 0;
+            }
+            void QXYSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
+            {
+                XYChart *item = static_cast<XYChart *>(m_item.data());
+                Q_ASSERT(item);
+                if (options.testFlag(QChart::SeriesAnimations)) {
+                    item->setAnimation(new XYAnimation(item));
+                }else{
+                    item->setAnimation(0);
+                }
+                QAbstractSeriesPrivate::initializeAnimations(options);
+            }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"

src/xychart/qxyseries_p.h +5 -2

             public:
                 QXYSeriesPrivate(QXYSeries *q);
-                void scaleDomain(Domain &domain);
+                void initializeDomain();
+                void initializeAxes();
+                void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
                 QList<QLegendMarker*> createLegendMarkers(QLegend* legend);
-                void initializeAxis(QAbstractAxis *axis);
                 QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const;
+                QAbstractAxis* createDefaultAxis(Qt::Orientation orientation) const;
             Q_SIGNALS:
                 void updated();

src/xychart/xychart.cpp +10 -84

@@ -32,12 +32,8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
32		32
33	//TODO: optimize : remove points which are not visible	33	//TODO: optimize : remove points which are not visible
34		34
35	XYChart::XYChart(QXYSeries series, ~~ChartPresenter~~ ~~presenter~~)	35	XYChart::XYChart(QXYSeries series,QGraphicsItem item):
36	: ~~ChartElement~~(~~presenter~~),	36	ChartItem(series->d_func(),item),
37	m_minX(0),
38	m_maxX(0),
39	m_minY(0),
40	m_maxY(0),
41	m_series(series),	37	m_series(series),
42	m_animation(0),	38	m_animation(0),
43	m_dirty(true)	39	m_dirty(true)
@@ -55,11 +51,6 void XYChart::setGeometryPoints(const QVector<QPointF>& points)
55	m_points = points;	51	m_points = points;
56	}	52	}
57		53
58	void XYChart::setClipRect(const QRectF &rect)
59	{
60	m_clipRect = rect;
61	}
62
63	void XYChart::setAnimation(XYAnimation *animation)	54	void XYChart::setAnimation(XYAnimation *animation)
64	{	55	{
65	m_animation = animation;	56	m_animation = animation;
@@ -70,51 +61,6 void XYChart::setDirty(bool dirty)
70	m_dirty = dirty;	61	m_dirty = dirty;
71	}	62	}
72		63
73	QPointF XYChart::calculateGeometryPoint(const QPointF &point) const
74	{
75	const qreal deltaX = m_size.width() / (m_maxX - m_minX);
76	const qreal deltaY = m_size.height() / (m_maxY - m_minY);
77	qreal x = (point.x() - m_minX) * deltaX;
78	qreal y = (point.y() - m_minY) * -deltaY + m_size.height();
79	return QPointF(x, y);
80	}
81
82	QPointF XYChart::calculateGeometryPoint(int index) const
83	{
84	const qreal deltaX = m_size.width() / (m_maxX - m_minX);
85	const qreal deltaY = m_size.height() / (m_maxY - m_minY);
86	const QList<QPointF>& vector = m_series->points();
87	qreal x = (vector[index].x() - m_minX) * deltaX;
88	qreal y = (vector[index].y() - m_minY) * -deltaY + m_size.height();
89	return QPointF(x, y);
90	}
91
92	QVector<QPointF> XYChart::calculateGeometryPoints() const
93	{
94	const qreal deltaX = m_size.width() / (m_maxX - m_minX);
95	const qreal deltaY = m_size.height() / (m_maxY - m_minY);
96
97	QVector<QPointF> result;
98	result.resize(m_series->count());
99	const QList<QPointF>& vector = m_series->points();
100	for (int i = 0; i < m_series->count(); ++i) {
101	qreal x = (vector[i].x() - m_minX) * deltaX;
102	qreal y = (vector[i].y() - m_minY) * -deltaY + m_size.height();
103	result[i].setX(x);
104	result[i].setY(y);
105	}
106	return result;
107	}
108
109	QPointF XYChart::calculateDomainPoint(const QPointF &point) const
110	{
111	const qreal deltaX = m_size.width() / (m_maxX - m_minX);
112	const qreal deltaY = m_size.height() / (m_maxY - m_minY);
113	qreal x = point.x() / deltaX + m_minX;
114	qreal y = (point.y() - m_size.height()) / (-deltaY) + m_minY;
115	return QPointF(x, y);
116	}
117
118	void XYChart::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)	64	void XYChart::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
119	{	65	{
120		66
@@ -139,10 +85,10 void XYChart::handlePointAdded(int index)
139	QVector<QPointF> points;	85	QVector<QPointF> points;
140		86
141	if (m_dirty) {	87	if (m_dirty) {
142	points = calculateGeometryPoints();	88	points = domain()->calculateGeometryPoints(m_series->points());
143	} else {	89	} else {
144	points = m_points;	90	points = m_points;
145	QPointF point = calculateGeometryPoint(index);	91	QPointF point = domain()->calculateGeometryPoint(m_series->points()[index]);
146	points.insert(index, point);	92	points.insert(index, point);
147	}	93	}
148		94
@@ -157,7 +103,7 void XYChart::handlePointRemoved(int index)
157	QVector<QPointF> points;	103	QVector<QPointF> points;
158		104
159	if (m_dirty) {	105	if (m_dirty) {
160	points = calculateGeometryPoints();	106	points = domain()->calculateGeometryPoints(m_series->points());
161	} else {	107	} else {
162	points = m_points;	108	points = m_points;
163	points.remove(index);	109	points.remove(index);
@@ -174,9 +120,9 void XYChart::handlePointReplaced(int index)
174	QVector<QPointF> points;	120	QVector<QPointF> points;
175		121
176	if (m_dirty) {	122	if (m_dirty) {
177	points = calculateGeometryPoints();	123	points = domain()->calculateGeometryPoints(m_series->points());
178	} else {	124	} else {
179	QPointF point = calculateGeometryPoint(index);	125	QPointF point = domain()->calculateGeometryPoint(m_series->points()[index]);
180	points = m_points;	126	points = m_points;
181	points.replace(index, point);	127	points.replace(index, point);
182	}	128	}
@@ -187,40 +133,20 void XYChart::handlePointReplaced(int index)
187	void XYChart::handlePointsReplaced()	133	void XYChart::handlePointsReplaced()
188	{	134	{
189	// All the points were replaced -> recalculate	135	// All the points were replaced -> recalculate
190	QVector<QPointF> points = calculateGeometryPoints();	136	QVector<QPointF> points = domain()->calculateGeometryPoints(m_series->points());
191	updateChart(m_points, points, -1);	137	updateChart(m_points, points, -1);
192	}	138	}
193		139
194	void XYChart::handleDomainUpdated()	140	void XYChart::handleDomainUpdated()
195	{	141	{
196	m_minX = domain()->minX();
197	m_maxX = domain()->maxX();
198	m_minY = domain()->minY();
199	m_maxY = domain()->maxY();
200	if (isEmpty()) return;	142	if (isEmpty()) return;
201		143	QVector<QPointF> points = domain()->calculateGeometryPoints(m_series->points());
202	QVector<QPointF> points = calculateGeometryPoints();
203
204	updateChart(m_points, points);
205	}
206
207	void XYChart::handleGeometryChanged(const QRectF &rect)
208	{
209	Q_ASSERT(rect.isValid());
210	m_size = rect.size();
211	m_clipRect = rect.translated(-rect.topLeft());
212	m_origin = rect.topLeft();
213
214	if (isEmpty()) return;
215
216	QVector<QPointF> points = calculateGeometryPoints();
217
218	updateChart(m_points, points);	144	updateChart(m_points, points);
219	}	145	}
220		146
221	bool XYChart::isEmpty()	147	bool XYChart::isEmpty()
222	{	148	{
223	return !m_clipRect.isValid() \|\| qFuzzyCompare(m_maxX, m_minX) \|\| qFuzzyCompare(m_maxY, m_minY) \|\| m_series->points().isEmpty();	149	return domain()->isEmpty() \|\| m_series->points().isEmpty();
224	}	150	}
225		151
226	#include "moc_xychart_p.cpp"	152	#include "moc_xychart_p.cpp"

src/xychart/xychart_p.h +2 -20

             class ChartPresenter;
             class QXYSeries;
-            class XYChart :  public ChartElement
+            class XYChart :  public ChartItem
             {
                 Q_OBJECT
             public:
-                explicit XYChart(QXYSeries *series, ChartPresenter *presenter);
+                explicit XYChart(QXYSeries *series,QGraphicsItem* item = 0);
                 ~XYChart() {}
                 void setGeometryPoints(const QVector<QPointF>& points);
                 QVector<QPointF> geometryPoints() const { return m_points; }
-                void setClipRect(const QRectF &rect);
-                QRectF clipRect() const { return m_clipRect; }
-                QSizeF size() const { return m_size; }
-                QPointF origin() const { return m_origin; }
                 void setAnimation(XYAnimation *animation);
                 ChartAnimation *animation() const { return m_animation; }
                 virtual void updateGeometry() = 0;
                 void handlePointReplaced(int index);
                 void handlePointsReplaced();
                 void handleDomainUpdated();
-                void handleGeometryChanged(const QRectF &size);
             Q_SIGNALS:
                 void clicked(const QPointF &point);
             protected:
                 virtual void updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index = -1);
-                QPointF calculateGeometryPoint(const QPointF &point) const;
-                QPointF calculateGeometryPoint(int index) const;
-                QPointF calculateDomainPoint(const QPointF &point) const;
-                QVector<QPointF> calculateGeometryPoints() const;
             private:
                 inline bool isEmpty();
             protected:
-                qreal m_minX;
-                qreal m_maxX;
-                qreal m_minY;
-                qreal m_maxY;
                 QXYSeries *m_series;
-                QSizeF m_size;
-                QPointF m_origin;
-                QRectF m_clipRect;
                 QVector<QPointF> m_points;
                 XYAnimation *m_animation;
                 bool m_dirty;

tests/auto/chartdataset/tst_chartdataset.cpp +191 -353

This diff has been collapsed as it changes many lines, (544 lines changed) Show them Hide them
	@@ -43,6 +43,8 QTEST_MAIN(tst_ChartDataSet)
	43	#include <qabstractaxis.h>	43	#include <qabstractaxis.h>
	44	#include <qvalueaxis.h>	44	#include <qvalueaxis.h>
	45	#include <qbarcategoryaxis.h>	45	#include <qbarcategoryaxis.h>
			46	#include <qcategoryaxis.h>
			47	#include <qdatetimeaxis.h>
	46	#include <qlineseries.h>	48	#include <qlineseries.h>
	47	#include <qareaseries.h>	49	#include <qareaseries.h>
	48	#include <qscatterseries.h>	50	#include <qscatterseries.h>
	@@ -62,6 +64,8 Q_DECLARE_METATYPE(QAbstractAxis *)
	62	Q_DECLARE_METATYPE(QAbstractSeries *)	64	Q_DECLARE_METATYPE(QAbstractSeries *)
	63	Q_DECLARE_METATYPE(QList<QAbstractSeries *>)	65	Q_DECLARE_METATYPE(QList<QAbstractSeries *>)
	64	Q_DECLARE_METATYPE(QList<QAbstractAxis *>)	66	Q_DECLARE_METATYPE(QList<QAbstractAxis *>)
			67	Q_DECLARE_METATYPE(Qt::Alignment)
			68	Q_DECLARE_METATYPE(QList<Qt::Alignment>)
	65	Q_DECLARE_METATYPE(QLineSeries *)	69	Q_DECLARE_METATYPE(QLineSeries *)
	66		70
	67	class tst_ChartDataSet: public QObject {	71	class tst_ChartDataSet: public QObject {
	@@ -79,26 +83,20 private Q_SLOTS:
	79	void chartdataset();	83	void chartdataset();
	80	void addSeries_data();	84	void addSeries_data();
	81	void addSeries();	85	void addSeries();
	82	void setAxisX_data();
	83	void setAxisX();
	84	void setAxisY_data();
	85	void setAxisY();
	86	void removeSeries_data();	86	void removeSeries_data();
	87	void removeSeries();	87	void removeSeries();
	88	void removeAllSeries_data();	88	void removeAllSeries_data();
	89	void removeAllSeries();	89	void removeAllSeries();
	90	void ~~seriesCount~~_data();	90	void addAxis_data();
	91	void ~~seriesCount~~();	91	void addAxis();
	92	void ~~seriesIndex~~_data();	92	void removeAxis_data();
	93	void seriesIndex();	93	void removeAxis();
	94	void ~~domain~~_data();	94	void removeAllAxes_data();
	95	void ~~domain~~();	95	void removeAllAxes();
	96	void ~~zoomInDomain~~_data();	96	void attachAxis_data();
	97	void ~~zoomInDomain~~();	97	void attachAxis();
	98	void ~~zoomOutDomain~~_data();	98	void detachAxis_data();
	99	void ~~zoomOutDomain~~();	99	void detachAxis();
	100	void scrollDomain_data();
	101	void scrollDomain();
	102		100
	103	private:	101	private:
	104	ChartDataSet* m_dataset;	102	ChartDataSet* m_dataset;
	@@ -117,7 +115,7 void tst_ChartDataSet::cleanupTestCase()
	117		115
	118	void tst_ChartDataSet::init()	116	void tst_ChartDataSet::init()
	119	{	117	{
	120	m_dataset = new ChartDataSet();	118	m_dataset = new ChartDataSet(0);
	121	}	119	}
	122		120
	123		121
	@@ -136,14 +134,9 void tst_ChartDataSet::chartdataset_data()
	136		134
	137	void tst_ChartDataSet::chartdataset()	135	void tst_ChartDataSet::chartdataset()
	138	{	136	{
	139	QVERIFY(m_dataset->ax~~isX~~(0) == 0);	137	QVERIFY(m_dataset->axes().isEmpty());
	140	QVERIFY(m_dataset->~~axisY~~(0) == 0);	138	QVERIFY(m_dataset->series().isEmpty());
	141	QLineSeries* series = new QLineSeries(this);	139	m_dataset->createDefaultAxes();
	142	QCOMPARE(m_dataset->seriesIndex(series),-1);
	143	QVERIFY(m_dataset->domain(series) == 0);
	144	QVERIFY(m_dataset->axisX(series) == 0);
	145	QVERIFY(m_dataset->axisY(series) == 0);
	146	m_dataset->createDefaultAxes();
	147	}	140	}
	148		141
	149		142
	@@ -172,143 +165,21 void tst_ChartDataSet::addSeries_data()
	172		165
	173	void tst_ChartDataSet::addSeries()	166	void tst_ChartDataSet::addSeries()
	174	{	167	{
	175
	176	QFETCH(QAbstractSeries*, series);	168	QFETCH(QAbstractSeries*, series);
			169	QVERIFY(m_dataset->series().isEmpty());
	177		170
	178	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis,~~Domain~~)));	171	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
	179	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));	172	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
	180	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries,~~Domain~~)));	173	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
	181	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));	174	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
	182		175
	183	m_dataset->addSeries(series);	176	m_dataset->addSeries(series);
	184	m_dataset->createDefaultAxes();
	185	if(series->type()==QAbstractSeries::SeriesTypePie){
	186	TRY_COMPARE(spy0.count(), 0);
	187	}else{
	188	TRY_COMPARE(spy0.count(), 2);
	189	}
	190	TRY_COMPARE(spy1.count(), 0);
	191	TRY_COMPARE(spy2.count(), 1);
	192	TRY_COMPARE(spy3.count(), 0);
	193	}
	194
	195
	196	void tst_ChartDataSet::setAxisX_data()
	197	{
	198	QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
	199	QTest::addColumn<QList<QAbstractAxis*> >("axisList");
	200	QTest::addColumn<int>("axisCount");
	201
	202	QAbstractSeries* line = new QLineSeries(this);
	203	QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
	204	QAbstractSeries* scatter = new QScatterSeries(this);
	205	QAbstractSeries* spline = new QSplineSeries(this);
	206	/QAbstractSeries pie = */new QPieSeries(this);
	207	/QAbstractSeries bar = */new QBarSeries(this);
	208	/QAbstractSeries percent = */new QPercentBarSeries(this);
	209	/QAbstractSeries stacked = */new QStackedBarSeries(this);
	210
	211	QTest::newRow("line,spline,scatter: axis 0 axis1 axis 2")
	212	<< (QList<QAbstractSeries*>() << line << spline << scatter)
	213	<< (QList<QAbstractAxis*>() << new QValueAxis(this) << new QValueAxis(this) << new QValueAxis(this)) << 3;
	214
	215	QTest::newRow("area: axis 0") << (QList<QAbstractSeries*>() << area)
	216	<< (QList<QAbstractAxis*>() << new QValueAxis(this)) << 1;
	217
	218	QList<QAbstractAxis*> axes0;
	219	axes0 << new QValueAxis(this) << new QValueAxis(this);
	220	axes0 << axes0.last();
	221	QTest::newRow("line,spline,scatter: axis 0 axis1 axis 1")
	222	<< (QList<QAbstractSeries*>() << line << spline << scatter)
	223	<< axes0 << 2;
	224	//TODO: add more test cases
	225	}
	226
	227	void tst_ChartDataSet::setAxisX()
	228	{
	229	QFETCH(QList<QAbstractSeries*>, seriesList);
	230	QFETCH(QList<QAbstractAxis*>, axisList);
	231	QFETCH(int, axisCount);
	232
	233	Q_ASSERT(seriesList.count() == axisList.count());
	234
	235	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis,Domain)));
	236	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
	237	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries,Domain)));
	238	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
	239
	240	foreach (QAbstractSeries* series, seriesList){
	241	m_dataset->addSeries(series);
	242	}
	243		177
			178	QCOMPARE(m_dataset->series().count(),1);
	244	TRY_COMPARE(spy0.count(), 0);	179	TRY_COMPARE(spy0.count(), 0);
	245	TRY_COMPARE(spy1.count(), 0);	180	TRY_COMPARE(spy1.count(), 0);
	246	TRY_COMPARE(spy2.count(), ~~seriesList~~.~~count~~());	181	TRY_COMPARE(spy2.count(), 1);
	247	TRY_COMPARE(spy3.count(), 0);
	248
	249	QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis,Domain)));
	250	QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
	251	QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries,Domain)));
	252	QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
	253
	254	for(int i=0 ; i < seriesList.count(); i++){
	255	m_dataset->setAxis(seriesList.at(i),axisList.at(i),Qt::Horizontal);
	256	}
	257
	258	TRY_COMPARE(spy4.count(), axisCount);
	259	TRY_COMPARE(spy5.count(), 0);
	260	TRY_COMPARE(spy6.count(), 0);
	261	TRY_COMPARE(spy7.count(), 0);
	262
	263	for(int i=0 ; i < seriesList.count(); i++){
	264	QVERIFY(m_dataset->axisX(seriesList.at(i)) == axisList.at(i));
	265	}
	266	}
	267
	268	void tst_ChartDataSet::setAxisY_data()
	269	{
	270	setAxisX_data();
	271	}
	272
	273	void tst_ChartDataSet::setAxisY()
	274	{
	275	QFETCH(QList<QAbstractSeries*>, seriesList);
	276	QFETCH(QList<QAbstractAxis*>, axisList);
	277	QFETCH(int, axisCount);
	278
	279	Q_ASSERT(seriesList.count() == axisList.count());
	280
	281	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis,Domain)));
	282	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
	283	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries,Domain)));
	284	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
	285
	286	foreach (QAbstractSeries* series, seriesList){
	287	m_dataset->addSeries(series);
	288	}
	289
	290	TRY_COMPARE(spy0.count(), 0);
	291	TRY_COMPARE(spy1.count(), 0);
	292	TRY_COMPARE(spy2.count(), seriesList.count());
	293	TRY_COMPARE(spy3.count(), 0);	182	TRY_COMPARE(spy3.count(), 0);
	294
	295	QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis,Domain)));
	296	QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
	297	QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries,Domain)));
	298	QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
	299
	300	for(int i=0 ; i < seriesList.count(); i++){
	301	m_dataset->setAxis(seriesList.at(i),axisList.at(i),Qt::Vertical);
	302	}
	303
	304	TRY_COMPARE(spy4.count(), axisCount);
	305	TRY_COMPARE(spy5.count(), 0);
	306	TRY_COMPARE(spy6.count(), 0);
	307	TRY_COMPARE(spy7.count(), 0);
	308
	309	for(int i=0 ; i < seriesList.count(); i++){
	310	QVERIFY(m_dataset->axisY(seriesList.at(i)) == axisList.at(i));
	311	}
	312	}	183	}
	313		184
	314	void tst_ChartDataSet::removeSeries_data()	185	void tst_ChartDataSet::removeSeries_data()
	@@ -319,24 +190,19 void tst_ChartDataSet::removeSeries_data()
	319	void tst_ChartDataSet::removeSeries()	190	void tst_ChartDataSet::removeSeries()
	320	{	191	{
	321	QFETCH(QAbstractSeries*, series);	192	QFETCH(QAbstractSeries*, series);
	322		193	QVERIFY(m_dataset->series().isEmpty());
	323	m_dataset->addSeries(series);	194	m_dataset->addSeries(series);
	324	m_dataset->createDefaultAxes();
	325		195
	326	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis,~~Domain~~)));	196	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
	327	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));	197	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
	328	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries,~~Domain~~)));	198	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
	329	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));	199	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
	330		200
	331	m_dataset->removeSeries(series);	201	m_dataset->removeSeries(series);
	332		202
			203	QCOMPARE(m_dataset->series().count(),0);
	333	TRY_COMPARE(spy0.count(), 0);	204	TRY_COMPARE(spy0.count(), 0);
	334	if (series->type() == QAbstractSeries::SeriesTypePie) {	205	TRY_COMPARE(spy1.count(), 0);
	335	TRY_COMPARE(spy1.count(), 0);
	336	}
	337	else {
	338	TRY_COMPARE(spy1.count(), 2);
	339	}
	340	TRY_COMPARE(spy2.count(), 0);	206	TRY_COMPARE(spy2.count(), 0);
	341	TRY_COMPARE(spy3.count(), 1);	207	TRY_COMPARE(spy3.count(), 1);
	342	}	208	}
	@@ -345,298 +211,270 void tst_ChartDataSet::removeAllSeries_data()
	345	{	211	{
	346	QTest::addColumn<QList<QAbstractSeries*> >("seriesList");	212	QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
	347	QTest::addColumn<QList<QAbstractAxis*> >("axisList");	213	QTest::addColumn<QList<QAbstractAxis*> >("axisList");
	348	QTest::addColumn<int>("axisCount");	214
	349		215	QList<QAbstractSeries*> series;
	350	QTest::newRow("line,spline,scatter: axis 0 axis1 axis 2")	216	QList<QAbstractAxis*> axis;
	351	<< (QList<QAbstractSeries*>() << new QLineSeries(this) << new QSplineSeries(this)	217
	352	<< new QScatterSeries(this))	218	series << new QLineSeries(this) << new QSplineSeries(this) << new QScatterSeries(this);
	353	<< (~~QList~~<~~QAbstractAxis~~*>() << new QValueAxis(this) << new QValueAxis(this)	219	axis << new QValueAxis(this) << new QValueAxis(this) << new QValueAxis(this);
	354	<< new QValueAxis(this)) << 3;	220
	355	//TODO:	221	QTest::newRow("3 series , 3 axis") << series << axis;
	356	}	222	}
	357		223
	358	void tst_ChartDataSet::removeAllSeries()	224	void tst_ChartDataSet::removeAllSeries()
	359	{	225	{
	360	QFETCH(QList<QAbstractSeries*>, seriesList);	226	QFETCH(QList<QAbstractSeries*>, seriesList);
	361	QFETCH(QList<QAbstractAxis*>, axisList);	227	QFETCH(QList<QAbstractAxis*>, axisList);
	362	QFETCH(int, axisCount);	228
			229	QCOMPARE(m_dataset->series().count(),0);
			230	QCOMPARE(m_dataset->axes().count(),0);
	363		231
	364	foreach (QAbstractSeries* series, seriesList) {	232	foreach (QAbstractSeries* series, seriesList) {
	365	m_dataset->addSeries(series);	233	m_dataset->addSeries(series);
	366	}	234	}
	367		235
			236	foreach (QAbstractAxis* axis, axisList) {
			237	m_dataset->addAxis(axis,Qt::AlignBottom);
			238	}
			239
	368	for (int i = 0; i < seriesList.count(); i++) {	240	for (int i = 0; i < seriesList.count(); i++) {
	369	m_dataset->~~set~~Axis(seriesList.at(i), axisList.at(i),Qt::~~Horizontal~~);	241	m_dataset->attachAxis(seriesList.at(i),axisList.at(i));
	370	}	242	}
	371		243
	372	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis,~~Domain~~)));	244	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
	373	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));	245	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
	374	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries,~~Domain~~)));	246	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
	375	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));	247	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
	376		248
	377	m_dataset->removeAllSeries();	249	m_dataset->removeAllSeries();
	378		250
	379	TRY_COMPARE(spy0.count(), 0);	251	TRY_COMPARE(spy0.count(), 0);
	380	TRY_COMPARE(spy1.count(), ~~axisCount~~);	252	TRY_COMPARE(spy1.count(), 0);
	381	TRY_COMPARE(spy2.count(), 0);	253	TRY_COMPARE(spy2.count(), 0);
	382	TRY_COMPARE(spy3.count(), seriesList.count());	254	TRY_COMPARE(spy3.count(), seriesList.count());
	383	}
	384		255
			256	QCOMPARE(m_dataset->series().count(),0);
			257	QCOMPARE(m_dataset->axes().count(),axisList.count());
			258	}
	385		259
	386	void tst_ChartDataSet::~~seriesCount~~_data()	260	void tst_ChartDataSet::addAxis_data()
	387	{	261	{
	388	QTest::addColumn<~~QList~~<QAbstract~~Serie~~s*> >("~~seriesList~~");	262	QTest::addColumn<QAbstractAxis*>("axis");
	389	QTest::addColumn<int>("seriesCount");	263	QAbstractAxis* value = new QValueAxis(this);
	390		264	QAbstractAxis* category = new QCategoryAxis(this);
	391	QTest::newRow("line,line, line, spline 3") << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) ) << 3;	265	QAbstractAxis* barcategory = new QBarCategoryAxis(this);
	392	QTest::newRow("scatter,scatter, line, line 2") << (QList<QAbstractSeries*>() << new QScatterSeries(this) << new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) ) << 2;	266	QAbstractAxis* datetime = new QDateTimeAxis(this);
			267
			268	QTest::newRow("value") << value;
			269	QTest::newRow("category") << category;
			270	QTest::newRow("barcategory") << barcategory;
			271	QTest::newRow("datetime") << datetime;
	393	}	272	}
	394		273
	395	void tst_ChartDataSet::~~seriesCount~~()	274	void tst_ChartDataSet::addAxis()
	396	{	275	{
	397	QFETCH(~~QList~~<QAbstract~~Serie~~s*>, ~~seriesList~~);	276	QFETCH(QAbstractAxis*, axis);
	398	QFETCH(int, seriesCount);	277	QVERIFY(m_dataset->axes().isEmpty());
	399		278
	400	foreach (QAbstractSeries* series, seriesList){	279	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
	401	m_dataset->addSeries(series);
	402	}
	403
	404	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis,Domain)));
	405	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));	280	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
	406	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries,~~Domain~~)));	281	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
	407	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));	282	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
	408		283
	409	QCOMPARE(m_dataset->seriesCount(seriesList.at(0)->type()),seriesCount);	284	m_dataset->addAxis(axis,Qt::AlignBottom);
	410	TRY_COMPARE(spy0.count(), 0);	285
			286	QCOMPARE(m_dataset->axes().count(),1);
			287	TRY_COMPARE(spy0.count(), 1);
	411	TRY_COMPARE(spy1.count(), 0);	288	TRY_COMPARE(spy1.count(), 0);
	412	TRY_COMPARE(spy2.count(), 0);	289	TRY_COMPARE(spy2.count(), 0);
	413	TRY_COMPARE(spy3.count(), 0);	290	TRY_COMPARE(spy3.count(), 0);
	414	}	291	}
	415		292
	416	void tst_ChartDataSet::~~seriesIndex~~_data()	293	void tst_ChartDataSet::removeAxis_data()
	417	{	294	{
	418	QTest::addColumn<QList<QAbstractSeries*> >("seriesList");	295	addAxis_data();
	419
	420	QTest::newRow("line,line, line, spline") << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) );
	421	QTest::newRow("scatter,scatter, line, line") << (QList<QAbstractSeries*>() << new QScatterSeries(this) << new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) );
	422	}	296	}
	423		297
	424	void tst_ChartDataSet::~~seriesIndex~~()	298	void tst_ChartDataSet::removeAxis()
	425	{	299	{
			300	QFETCH(QAbstractAxis*, axis);
			301	QVERIFY(m_dataset->series().isEmpty());
			302	m_dataset->addAxis(axis,Qt::AlignBottom);
	426		303
	427	QFETCH(QList<QAbstractSeries*>, seriesList);	304	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
	428
	429	foreach (QAbstractSeries* series, seriesList) {
	430	m_dataset->addSeries(series);
	431	}
	432
	433	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis,Domain)));
	434	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));	305	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
	435	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries,~~Domain~~)));	306	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
	436	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));	307	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
	437		308
	438	for (int i = 0; i < seriesList.count(); i++) {	309	m_dataset->removeAxis(axis);
	439	QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
	440	}
	441		310
			311	QCOMPARE(m_dataset->series().count(),0);
	442	TRY_COMPARE(spy0.count(), 0);	312	TRY_COMPARE(spy0.count(), 0);
	443	TRY_COMPARE(spy1.count(), 0);	313	TRY_COMPARE(spy1.count(), 1);
	444	TRY_COMPARE(spy2.count(), 0);	314	TRY_COMPARE(spy2.count(), 0);
	445	TRY_COMPARE(spy3.count(), 0);	315	TRY_COMPARE(spy3.count(), 0);
			316	}
	446		317
	447	foreach (QAbstractSeries* series, seriesList) {	318	void tst_ChartDataSet::removeAllAxes_data()
	448	m_dataset->removeSeries(series);	319	{
	449	}	320	QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
	450		321	QTest::addColumn<QList<QAbstractAxis*> >("axisList");
	451	for (int i = 0; i < seriesList.count(); i++) {
	452	QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
	453	}
	454
	455	foreach (QAbstractSeries* series, seriesList) {
	456	m_dataset->addSeries(series);
	457	}
	458
	459	for (int i = 0; i < seriesList.count(); i++) {
	460	QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
	461	}
	462		322
	463	m_dataset->removeSeries(seriesList.at(1));	323	QList<QAbstractSeries*> series;
			324	QList<QAbstractAxis*> axis;
	464		325
	465	for (int i = 0; i < seriesList.count(); i++) {	326	series << new QLineSeries(this) << new QSplineSeries(this) << new QScatterSeries(this);
	466	if (i != 1)	327	axis << new QValueAxis(this) << new QValueAxis(this) << new QValueAxis(this);
	467	QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
	468	else
	469	QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
	470	}
	471		328
	472	m_dataset->addSeries(seriesList.at(1));	329	QTest::newRow("3 series , 3 axis") << series << axis;
			330	}
	473		331
	474	for (int i = 0; i < seriesList.count(); i++) {	332	void tst_ChartDataSet::removeAllAxes()
	475	QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);	333	{
	476	}	334	QFETCH(QList<QAbstractSeries*>, seriesList);
			335	QFETCH(QList<QAbstractAxis*>, axisList);
	477		336
	478	m_dataset->~~removeS~~eries(~~seriesList~~.at(2));	337	QCOMPARE(m_dataset->series().count(),0);
			338	QCOMPARE(m_dataset->axes().count(),0);
	479		339
	480	for (int i = 0; i < seriesList.count(); i++) {	340	foreach (QAbstractSeries* series, seriesList) {
	481	if (i != 2)	341	m_dataset->addSeries(series);
	482	QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
	483	else
	484	QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
	485	}	342	}
	486		343
	487	m_dataset->removeSeries(seriesList.at(0));	344	foreach (QAbstractAxis* axis, axisList) {
	488		345	m_dataset->addAxis(axis,Qt::AlignBottom);
	489	for (int i = 0; i < seriesList.count(); i++) {
	490	if (i != 2 && i != 0)
	491	QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
	492	else
	493	QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
	494	}	346	}
	495		347
	496	m_dataset->addSeries(seriesList.at(2));
	497	m_dataset->addSeries(seriesList.at(0));
	498
	499	for (int i = 0; i < seriesList.count(); i++) {	348	for (int i = 0; i < seriesList.count(); i++) {
	500	if (i == 2)	349	m_dataset->attachAxis(seriesList.at(i),axisList.at(i));
	501	QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 0);
	502	else if (i == 0)
	503	QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 2);
	504	else
	505	QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
	506	}	350	}
	507		351
	508	}	352	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
	509
	510	void tst_ChartDataSet::domain_data()
	511	{
	512	addSeries_data();
	513	}
	514
	515	void tst_ChartDataSet::domain()
	516	{
	517	QFETCH(QAbstractSeries*, series);
	518
	519	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis,Domain)));
	520	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));	353	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
	521	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries,~~Domain~~)));	354	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
	522	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));	355	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
	523		356
	524	m_dataset->~~addSeri~~es(~~series~~);	357	m_dataset->removeAllAxes();
	525	QVERIFY(m_dataset->domain(series));
	526
	527		358
	528	TRY_COMPARE(spy0.count(), 0);	359	TRY_COMPARE(spy0.count(), 0);
	529	TRY_COMPARE(spy1.count(), 0);	360	TRY_COMPARE(spy1.count(), axisList.count());
	530	TRY_COMPARE(spy2.count(), 1);	361	TRY_COMPARE(spy2.count(), 0);
	531
	532	QList<QVariant> arguments = spy2.takeFirst();
	533	Domain domain = (Domain ) arguments.at(1).value<Domain *>();
	534	QVERIFY(m_dataset->domain(series) == domain);
	535
	536	TRY_COMPARE(spy3.count(), 0);	362	TRY_COMPARE(spy3.count(), 0);
	537		363
			364	QCOMPARE(m_dataset->series().count(),seriesList.count());
			365	QCOMPARE(m_dataset->axes().count(),0);
	538	}	366	}
	539		367
	540	void tst_ChartDataSet::~~zoomInDomain~~_data()	368	void tst_ChartDataSet::attachAxis_data()
	541	{
	542	QTest::addColumn<bool >("sameAxis");
	543	QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
	544	QTest::newRow("sameAxis: line,line, line, spline") << true << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) );
	545	QTest::newRow("separeateAxis: line,line, line, spline") << false << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) );
	546	}
	547
	548	void tst_ChartDataSet::zoomInDomain()
	549	{	369	{
	550	QFETCH(bool, sameAxis);	370	QTest::addColumn<QList<QAbstractSeries*> >("series");
	551	Q~~FETCH~~(QList<QAbstract~~Serie~~s*>, ~~seriesList~~);	371	QTest::addColumn<QList<QAbstractAxis*> >("axis");
	552		372	QTest::addColumn<QList<Qt::Alignment> >("alignment");
	553	foreach (QAbstractSeries* series, seriesList) {	373	QTest::addColumn<QAbstractSeries*>("attachSeries");
	554	m_dataset->addSeries(series);	374	QTest::addColumn<QAbstractAxis*>("attachAxis");
	555	}	375	QTest::addColumn<bool>("success");
	556
	557	if(sameAxis) m_dataset->createDefaultAxes();
	558
	559	QList<QSignalSpy*> spyList;
	560
	561	foreach (QAbstractSeries* series, seriesList) {
	562	spyList << new QSignalSpy(m_dataset->domain(series),SIGNAL(updated()));
	563	}
	564		376
	565	m_dataset->zoomInDomain(QRect(0, 0, 100, 100), QSize(1000, 1000));	377	QList<QAbstractSeries*> series;
			378	QList<QAbstractAxis*> axes;
			379	QList<Qt::Alignment> alignment;
	566		380
	567	foreach (QSignalSpy* spy, spyList) {	381	QAbstractSeries* line = new QLineSeries(this);
	568	TRY_COMPARE(spy->count(), 1);	382	QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
	569	}	383	QAbstractSeries* scatter = new QScatterSeries(this);
			384	QAbstractSeries* spline = new QSplineSeries(this);
			385	QAbstractSeries* pie = new QPieSeries(this);
			386	QAbstractSeries* bar = new QBarSeries(this);
			387	QAbstractSeries* percent = new QPercentBarSeries(this);
			388	QAbstractSeries* stacked = new QStackedBarSeries(this);
	570		389
	571	qDeleteAll(spyList);	390	QAbstractAxis* value1 = new QValueAxis(this);
	572	}	391	QAbstractAxis* value2 = new QValueAxis(this);
			392	QAbstractAxis* category = new QCategoryAxis(this);
			393	QAbstractAxis* barcategory = new QBarCategoryAxis(this);
			394	QAbstractAxis* datetime = new QDateTimeAxis(this);
	573		395
	574		396
			397	series << line << 0;
			398	axes << value1 << value2;
			399	alignment << Qt::AlignBottom << Qt::AlignLeft;
			400	QTest::newRow("line + two axes") << series << axes << alignment << line << value2 << true;
	575		401
	576	void tst_ChartDataSet::zoomOutDomain_data()
	577	{
	578	zoomInDomain_data();
	579	}	402	}
	580		403
	581	void tst_ChartDataSet::~~zoomOutDomain~~()	404	void tst_ChartDataSet::attachAxis()
	582	{	405	{
	583	QFETCH(bool, sameAxis);	406	QFETCH(QList<QAbstractSeries*>, series);
	584	QFETCH(QList<QAbstract~~Serie~~s*>, ~~seriesList~~);	407	QFETCH(QList<QAbstractAxis*>, axis);
	585		408	QFETCH(QList<Qt::Alignment>, alignment);
	586	foreach (QAbstractSeries* series, seriesList) {	409	QFETCH(QAbstractSeries*, attachSeries);
	587	m_dataset->addSeries(series);	410	QFETCH(QAbstractAxis*, attachAxis);
	588	}	411	QFETCH(bool, success);
	589		412
	590	if (sameAxis)	413	Q_ASSERT(series.count() == axis.count());
	591	m_dataset->createDefaultAxes();	414	Q_ASSERT(series.count() == alignment.count());
	592		415
	593	QList<QSignalSpy*> spyList;	416	QVERIFY(m_dataset->series().isEmpty());
			417	QVERIFY(m_dataset->axes().isEmpty());
	594		418
	595	foreach (QAbstractSeries* series, seriesList) {	419	for(int i = 0 ; i < series.count() ; i++){
	596	spyList << new QSignalSpy(m_dataset->domain(series), SIGNAL(updated()));	420	if(series[i]) m_dataset->addSeries(series[i]);
			421	if(axis[i]) m_dataset->addAxis(axis[i],alignment[i]);
			422	if(series[i] && axis[i]) m_dataset->attachAxis(series[i],axis[i]);
	597	}	423	}
	598		424
	599	m_dataset->zoomOutDomain(QRect(0, 0, 100, 100), QSize(1000, 1000));	425	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
			426	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
			427	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
			428	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
	600		429
	601	foreach (QSignalSpy* spy, spyList) {	430	QCOMPARE(m_dataset->attachAxis(attachSeries,attachAxis),success);
	602	TRY_COMPARE(spy->count(), 1);
	603	}
	604		431
	605	qDeleteAll (spyList);
	606	}	432	}
	607		433
	608	void tst_ChartDataSet::~~scrollDomain~~_data()	434	void tst_ChartDataSet::detachAxis_data()
	609	{	435	{
	610	zoomInDomain_data();	436	QTest::addColumn<QList<QAbstractSeries*> >("series");
	611	}	437	QTest::addColumn<QList<QAbstractAxis*> >("axis");
			438	QTest::addColumn<QAbstractSeries*>("detachSeries");
			439	QTest::addColumn<QAbstractAxis*>("detachAxis");
			440	QTest::addColumn<bool>("success");
	612		441
	613	void tst_ChartDataSet::scrollDomain()	442	QList<QAbstractSeries*> series;
	614	{	443	QList<QAbstractAxis*> axes;
	615	QFETCH(bool, sameAxis);
	616	QFETCH(QList<QAbstractSeries*>, seriesList);
	617		444
	618	foreach (QAbstractSeries* series, seriesList) {	445	QAbstractSeries* line = new QLineSeries(this);
	619	m_dataset->addSeries(series);	446	QAbstractAxis* value = new QValueAxis(this);
	620	}
	621		447
	622	if (sameAxis)	448	series << line;
	623	m_dataset->createDefaultAxes();	449	axes << value;
			450	QTest::newRow("line + axis") << series << axes << line << value << true;
			451	}
	624		452
	625	QList<QSignalSpy*> spyList;	453	void tst_ChartDataSet::detachAxis()
			454	{
			455	QFETCH(QList<QAbstractSeries*>, series);
			456	QFETCH(QList<QAbstractAxis*>, axis);
			457	QFETCH(QAbstractSeries*, detachSeries);
			458	QFETCH(QAbstractAxis*, detachAxis);
			459	QFETCH(bool, success);
	626		460
	627	foreach (QAbstractSeries* series, seriesList) {	461	Q_ASSERT(series.count() == axis.count());
	628	spyList
	629	<< new QSignalSpy(m_dataset->domain(series),
	630	SIGNAL(updated()));
	631	}
	632		462
	633	m_dataset->scrollDomain(10, 10, QSize(1000, 1000));	463	QVERIFY(m_dataset->series().isEmpty());
			464	QVERIFY(m_dataset->axes().isEmpty());
	634		465
	635	foreach (QSignalSpy* spy, spyList) {	466	for(int i = 0; i < series.count(); i++) {
	636	TRY_COMPARE(spy->count(), 1);	467	if(series[i]) m_dataset->addSeries(series[i]);
			468	if(axis[i]) m_dataset->addAxis(axis[i],Qt::AlignBottom);
			469	if(series[i] && axis[i]) m_dataset->attachAxis(series[i],axis[i]);
	637	}	470	}
	638		471
	639	qDeleteAll(spyList);	472	QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
			473	QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
			474	QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
			475	QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
			476
			477	QCOMPARE(m_dataset->detachAxis(detachSeries,detachAxis),success);
	640	}	478	}
	641		479
	642	QTEST_MAIN(tst_ChartDataSet)	480	QTEST_MAIN(tst_ChartDataSet)

tests/auto/domain/tst_domain.cpp +152 -113

             Q_DECLARE_METATYPE(Domain*)
             Q_DECLARE_METATYPE(QSizeF)
+            Q_DECLARE_METATYPE(QMargins)
             class AxisMock: public QAbstractAxisPrivate
             {
             Q_OBJECT
             public:
-                AxisMock(Qt::Orientation orientation):QAbstractAxisPrivate(0){ setOrientation(orientation);};
+                AxisMock(Qt::Alignment alignment):QAbstractAxisPrivate(0){ setAlignment(alignment);};
-                ChartAxis* createGraphics(ChartPresenter* presenter)
+                void initializeGraphics(QGraphicsItem* item)
                 {
-                    Q_UNUSED(presenter);
+                    Q_UNUSED(item);
-                    return 0;
                 };
-                void intializeDomain(Domain* domain)
+                void initializeDomain(Domain* domain)
                 {
                     Q_UNUSED(domain);
                 };
                     Q_UNUSED(max);
                 };
+                void setRange(qreal min, qreal max)
+                {
+                      m_min=min;
+                      m_max=max;
+                      emit rangeChanged(min,max);
+                };
                 int count () const { return m_count; }
                 void handleDomainUpdated(){};
             private Q_SLOTS:
                 void domain();
-                void handleAxisUpdatedX_data();
+                void handleHorizontalAxisRangeChanged_data();
-                void handleAxisUpdatedX();
+                void handleHorizontalAxisRangeChanged();
-                void handleAxisUpdatedY_data();
+                void handleVerticalAxisRangeChanged_data();
-                void handleAxisUpdatedY();
+                void handleVerticalAxisRangeChanged();
                 void isEmpty_data();
                 void isEmpty();
                 void maxX_data();
                 void spanX();
                 void spanY_data();
                 void spanY();
-                void zoom_data();
+                void zoomIn_data();
-                void zoom();
+                void zoomIn();
+                void zoomOut_data();
+                void zoomOut();
                 void move_data();
                 void move();
             };
                 QCOMPARE(domain.minY(), 0.0);
             }
-            void tst_Domain::handleAxisUpdatedX_data()
+            void tst_Domain::handleHorizontalAxisRangeChanged_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("-1 0") << -1.0 << 0.0;
             }
-            void tst_Domain::handleAxisUpdatedX()
+            void tst_Domain::handleHorizontalAxisRangeChanged()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
-                QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
+                QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
-                QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
+                QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
-                AxisMock axis(Qt::Horizontal);
+                AxisMock axis(Qt::AlignBottom);
-                QObject::connect(&axis,SIGNAL(updated()),&domain,SLOT(handleAxisUpdated()));
+                QObject::connect(&axis,SIGNAL(rangeChanged(qreal,qreal)),&domain,SLOT(handleHorizontalAxisRangeChanged(qreal,qreal)));
-                axis.m_min=min;
+                axis.setRange(min,max);
-                axis.m_max=max;
-                axis.emitUpdated();
                 QVERIFY(qFuzzyCompare(domain.minX(), min));
                 QVERIFY(qFuzzyCompare(domain.maxX(), max));
             }
-            void tst_Domain::handleAxisUpdatedY_data()
+            void tst_Domain::handleVerticalAxisRangeChanged_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("-1 0") << -1.0 << 0.0;
             }
-            void tst_Domain::handleAxisUpdatedY()
+            void tst_Domain::handleVerticalAxisRangeChanged()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
-                QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
+                QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
-                QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
+                QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
-                AxisMock axis(Qt::Vertical);
+                AxisMock axis(Qt::AlignLeft);
-                QObject::connect(&axis, SIGNAL(updated()), &domain, SLOT(handleAxisUpdated()));
+                QObject::connect(&axis, SIGNAL(rangeChanged(qreal,qreal)), &domain, SLOT(handleVerticalAxisRangeChanged(qreal,qreal)));
-                axis.m_min = min;
+                axis.setRange(min,max);
-                axis.m_max = max;
-                axis.emitUpdated();
                 QVERIFY(qFuzzyCompare(domain.minY(), min));
                 QVERIFY(qFuzzyCompare(domain.maxY(), max));
                 QTest::addColumn<qreal>("maxX");
                 QTest::addColumn<qreal>("minY");
                 QTest::addColumn<qreal>("maxY");
+                QTest::addColumn<QSizeF>("size");
                 QTest::addColumn<bool>("isEmpty");
-                QTest::newRow("0 0 0 0") << 0.0 << 0.0 << 0.0 << 0.0 << true;
+                QTest::newRow("0 0 0 0") << 0.0 << 0.0 << 0.0 << 0.0 << QSizeF(1,1) << true;
-                QTest::newRow("0 1 0 0") << 0.0 << 1.0 << 0.0 << 0.0 << true;
+                QTest::newRow("0 1 0 0") << 0.0 << 1.0 << 0.0 << 0.0 << QSizeF(1,1) << true;
-                QTest::newRow("0 0 0 1") << 0.0 << 1.0 << 0.0 << 0.0 << true;
+                QTest::newRow("0 0 0 1") << 0.0 << 1.0 << 0.0 << 0.0 << QSizeF(1,1) << true;
-                QTest::newRow("0 1 0 1") << 0.0 << 1.0 << 0.0 << 1.0 << false;
+                QTest::newRow("0 1 0 1") << 0.0 << 1.0 << 0.0 << 1.0 << QSizeF(1,1) << false;
+                QTest::newRow("0 1 0 1") << 0.0 << 1.0 << 0.0 << 1.0 << QSizeF(-11,1) << true;
             }
             void tst_Domain::isEmpty()
                 QFETCH(qreal, maxX);
                 QFETCH(qreal, minY);
                 QFETCH(qreal, maxY);
+                QFETCH(QSizeF, size);
                 QFETCH(bool, isEmpty);
                 Domain domain;
                 domain.setRange(minX, maxX, minY, maxY);
+                domain.setSize(size);
                 QCOMPARE(domain.isEmpty(), isEmpty);
             }
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
-                QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
+                QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
-                QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
+                QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 domain.setMaxX(maxX1);
                 QCOMPARE(domain.maxX(), maxX1);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
-                QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
+                QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
-                QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
+                QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 domain.setMaxY(maxY1);
                 QCOMPARE(domain.maxY(), maxY1);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
-                QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
+                QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
-                QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
+                QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 domain.setMinX(minX1);
                 QCOMPARE(domain.minX(), minX1);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
-                QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
+                QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
-                QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
+                QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 domain.setMinY(minY1);
                 QCOMPARE(domain.minY(), minY1);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
-                QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
+                QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
-                QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
+                QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 QCOMPARE(*domain1==*domain2, equals);
                 QCOMPARE(*domain1!=*domain2, notEquals);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
-                QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
+                QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
-                QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
+                QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 domain.setRange(minX, maxX, minY, maxY);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
-                QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
+                QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
-                QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
+                QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 domain.setRangeX(min, max);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
-                QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
+                QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
-                QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
+                QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 domain.setRangeY(min, max);
                 domain.setRangeX(minX, maxX);
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
-                QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
+                QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
-                QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
+                QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 QCOMPARE(domain.spanX(), spanX);
                 domain.setRangeY(minY, maxY);
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
-                QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
+                QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
-                QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
+                QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 QCOMPARE(domain.spanY(), spanY);
                 TRY_COMPARE(spy2.count(), 0);
             }
-            void tst_Domain::zoom_data()
+            void tst_Domain::zoomIn_data()
             {
-                QTest::addColumn<QRectF>("rect0");
+                QTest::addColumn<QMargins>("range");
-                QTest::addColumn<QSizeF>("size0");
+                QTest::addColumn<QSizeF>("size");
-                QTest::addColumn<QRectF>("rect1");
+                QTest::addColumn<QMargins>("zoom");
-                QTest::addColumn<QSizeF>("size1");
+                QTest::addColumn<QMargins>("result");
-                QTest::addColumn<QRectF>("rect2");
-                QTest::addColumn<QSizeF>("size2");
+                QTest::newRow("first") << QMargins(0,0,1000,1000) << QSizeF(1000, 1000) <<
-                QTest::newRow("first") << QRectF(10, 10, 100, 100) << QSizeF(1000, 1000)
+                						  QMargins(100, 100, 900, 900) << QMargins(100,100,900,900);
-                    << QRectF(20, 20, 100, 100) << QSizeF(1000, 1000) << QRectF(50, 50, 100, 100)
+                QTest::newRow("second") << QMargins(0,0,2000,2000) << QSizeF(1000, 1000) <<
-                    << QSizeF(1000, 1000);
+                						  QMargins(100, 100, 900, 900) << QMargins(200,200,1800,1800);
-                QTest::newRow("scound") << QRectF(10, 10, 50, 50) << QSizeF(1000, 1000)
-                    << QRectF(20, 20, 100, 100) << QSizeF(1000, 1000) << QRectF(50, 50, 100, 100)
-                    << QSizeF(1000, 1000);
-                QTest::newRow("third") << QRectF(10, 10, 10, 10) << QSizeF(100, 100) << QRectF(20, 20, 20, 20)
-                    << QSizeF(100, 100) << QRectF(50, 50, 50, 50) << QSizeF(100, 100);
             }
-            void tst_Domain::zoom()
+            void tst_Domain::zoomIn()
             {
-                QFETCH(QRectF, rect0);
+                QFETCH(QMargins, range);
-                QFETCH(QSizeF, size0);
+                QFETCH(QSizeF, size);
-                QFETCH(QRectF, rect1);
+                QFETCH(QMargins, zoom);
-                QFETCH(QSizeF, size1);
+                QFETCH(QMargins, result);
-                QFETCH(QRectF, rect2);
-                QFETCH(QSizeF, size2);
                 Domain domain;
+                domain.setRange(range.left(), range.right(), range.top(),range.bottom());
+                domain.setSize(size);
+                QSignalSpy spy0(&domain, SIGNAL(updated()));
+                QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
+                QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
+                domain.zoomIn(QRectF(zoom.left(),zoom.top(),zoom.right()-zoom.left(),zoom.bottom()-zoom.top()));
+                QCOMPARE(domain.minX(),qreal(result.left()));
+                QCOMPARE(domain.maxX(),qreal(result.right()));
+                QCOMPARE(domain.minY(),qreal(result.top()));
+                QCOMPARE(domain.maxY(),qreal(result.bottom()));
+                TRY_COMPARE(spy0.count(), 1);
+                TRY_COMPARE(spy1.count(), 1);
+                TRY_COMPARE(spy2.count(), 1);
+            }
+            void tst_Domain::zoomOut_data()
+            {
+                QTest::addColumn<QMargins>("range");
+                QTest::addColumn<QSizeF>("size");
+                QTest::addColumn<QMargins>("zoom");
+                QTest::addColumn<QMargins>("result");
+                QTest::newRow("first") << QMargins(100,100,900,900) << QSizeF(1000, 1000) <<
+                						  QMargins(100, 100, 900, 900) << QMargins(0,0,1000,1000);
+                QTest::newRow("second") << QMargins(200,200,1800,1800) << QSizeF(1000, 1000) <<
+                						  QMargins(100, 100, 900, 900) << QMargins(0,0,2000,2000);
+            }
+            void tst_Domain::zoomOut()
+            {
+                QFETCH(QMargins, range);
+                QFETCH(QSizeF, size);
+                QFETCH(QMargins, zoom);
+                QFETCH(QMargins, result);
-                domain.setRange(0, 1000, 0, 1000);
+                Domain domain;
+                domain.setRange(range.left(), range.right(), range.top(),range.bottom());
+                domain.setSize(size);
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
-                QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
+                QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
-                QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
+                QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
-                Domain domain0;
+                domain.zoomOut(QRectF(zoom.left(),zoom.top(),zoom.right()-zoom.left(),zoom.bottom()-zoom.top()));
-                domain0.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
-                domain.zoomIn(rect0, size0);
+                QCOMPARE(domain.minX(),qreal(result.left()));
-                Domain domain1;
+                QCOMPARE(domain.maxX(),qreal(result.right()));
-                domain1.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
+                QCOMPARE(domain.minY(),qreal(result.top()));
-                domain.zoomIn(rect1, size1);
+                QCOMPARE(domain.maxY(),qreal(result.bottom()));
-                Domain domain2;
-                domain2.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
+                TRY_COMPARE(spy0.count(), 1);
-                domain.zoomIn(rect2, size2);
+                TRY_COMPARE(spy1.count(), 1);
-                domain.zoomOut(rect2, size2);
+                TRY_COMPARE(spy2.count(), 1);
-                QCOMPARE(domain == domain2, true);
-                domain.zoomOut(rect1, size1);
-                QCOMPARE(domain == domain1, true);
-                domain.zoomOut(rect0, size0);
-                QCOMPARE(domain == domain0, true);
-                TRY_COMPARE(spy0.count(), 6);
-                TRY_COMPARE(spy1.count(), 6);
-                TRY_COMPARE(spy2.count(), 6);
             }
             void tst_Domain::move_data()
             {
+            	QTest::addColumn<QMargins>("range");
+            	QTest::addColumn<QSizeF>("size");
                 QTest::addColumn<int>("dx");
                 QTest::addColumn<int>("dy");
-                QTest::addColumn<QSizeF>("size");
+                QTest::addColumn<QMargins>("result");
-                QTest::newRow("dx 100, dy 0, size 1000x1000") << 100 << 0 << QSizeF(1000, 1000);
-                QTest::newRow("dx 0,  dy 100, size 1000x1000") << 0 << 100 << QSizeF(1000, 1000);
+                QTest::newRow("first") << QMargins(0,0,1000,1000) << QSizeF(1000, 1000) <<
-                QTest::newRow("dx -100, dy 0, size 1000x1000") << -100 << 0 << QSizeF(1000, 1000);
+<< 10 << QMargins(10,10,1010,1010);
-                QTest::newRow("dx 0, dy -100, size 1000x1000") << 0 << -100 << QSizeF(1000, 1000);
+                QTest::newRow("second") << QMargins(0,0,1000,1000) << QSizeF(1000, 1000) <<
-                QTest::newRow("dx 100, dy 100, size 1000x1000") << 100 << 100 << QSizeF(1000, 1000);
+                   						  -10 << -10 << QMargins(-10,-10,990,990);
-                QTest::newRow("dx 100, dy 50, size 1000x1000") << 100 << 50 << QSizeF(1000, 1000);
             }
             void tst_Domain::move()
             {
+                QFETCH(QMargins, range);
+                QFETCH(QSizeF, size);
                 QFETCH(int, dx);
                 QFETCH(int, dy);
-                QFETCH(QSizeF, size);
+                QFETCH(QMargins, result);
-                Domain domain;
-                domain.setRange(0, size.width(), 0, size.height());
+                Domain domain;
+                domain.setRange(range.left(), range.right(), range.top(),range.bottom());
+                domain.setSize(size);
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
-                QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
+                QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
-                QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
+                QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
-                domain.move(dx, dy, size);
+                domain.move(dx, dy);
-                Domain result;
+                QCOMPARE(domain.minX(),qreal(result.left()));
-                result.setRange(dx, size.width() + dx, dy, size.height() + dy);
+                QCOMPARE(domain.maxX(),qreal(result.right()));
+                QCOMPARE(domain.minY(),qreal(result.top()));
+                QCOMPARE(domain.maxY(),qreal(result.bottom()));
-                QCOMPARE(domain == result, true);
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), (dx != 0 ? 1 : 0));
                 TRY_COMPARE(spy2.count(), (dy != 0 ? 1 : 0));

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

                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
                 QSignalSpy spy0(m_axis, SIGNAL(lineVisibleChanged(bool)));
                 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
-                QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+                QSignalSpy spy2(m_axis, SIGNAL(gridLineVisibleChanged(bool)));
                 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
                 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
                 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));

tests/auto/qvalueaxis/tst_qvalueaxis.cpp +5 -6

                 void min();
                 void min_animation_data();
                 void min_animation();
-                void niceNumbersEnabled_data();
+                void applyNiceNumbers_data();
-                void niceNumbersEnabled();
+                void applyNiceNumbers();
                 void range_raw_data();
                 void range_raw();
                 void range_data();
                 min();
             }
-            void tst_QValueAxis::niceNumbersEnabled_data()
+            void tst_QValueAxis::applyNiceNumbers_data()
             {
                 QTest::addColumn<bool>("niceNumbersEnabled");
                 QTest::addColumn<qreal>("min");
                 QTest::newRow("true 5, 93.5 , 5") << true << (qreal)5.0 << (qreal)93.5 << 5 << (qreal)0.0 << (qreal)100.0 << 6;
             }
-            void tst_QValueAxis::niceNumbersEnabled()
+            void tst_QValueAxis::applyNiceNumbers()
             {
                 QFETCH(bool, niceNumbersEnabled);
                 QFETCH(qreal, min);
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
-                m_valuesaxis->setNiceNumbersEnabled(niceNumbersEnabled);
+                if(niceNumbersEnabled) m_valuesaxis->applyNiceNumbers();
-                QCOMPARE(m_valuesaxis->niceNumbersEnabled(), niceNumbersEnabled);
                 if(!qFuzzyCompare(expectedMin, min))
                     QCOMPARE(spy1.count(), 1);

src/charttheme.cpp removed 0 -399

NO CONTENT: file was removed

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