HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r421:fe0a0dc06876

Adds area chart...

Michal Klocek -

r421:fe0a0dc06876

parent child

Context file:

r421:fe0a0dc06876

Expand all files

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

NO CONTENT: new file 100644, binary diff hidden

doc/src/example-areachart.qdoc created 644 +30 0

@@ -0,0 +1,30
	1	/*!
	2	\example example/areachart
	3	\title AreaChart Example
	4	\subtitle
	5
	6	The example shows how to create simple area chart.
	7
	8	\image areachart.png
	9
	10	To create area charts, we need two QLineSeries instances. They are going to define upper and lower boundary of the area.
	11
	12	\snippet ../example/areachart/main.cpp 1
	13
	14	We add data to both series, we use stream operator.
	15
	16	\snippet ../example/areachart/main.cpp 2
	17
	18	Now we create QAreaSeries instance using two line series objects. We set the custom gradient fill and width of the outline.
	19
	20	\snippet ../example/areachart/main.cpp 3
	21
	22	In the end we create QChartView instance, set title, set anti-aliasing and add area series. We also set the specific range for axes.
	23
	24	\snippet ../example/areachart/main.cpp 4
	25
	26	Chart is ready to be shown.
	27
	28	\snippet ../example/areachart/main.cpp 5
	29
	30	*/ No newline at end of file

example/areachart/areachart.pro created 644 +8 0

@@ -0,0 +1,8
	1	!include( ../example.pri ) {
	2	error( "Couldn't find the example.pri file!" )
	3	}
	4	TARGET = areachart
	5	SOURCES += main.cpp
	6
	7
	8

example/areachart/main.cpp created 644 +59 0

@@ -0,0 +1,59
	1	#include <QApplication>
	2	#include <QMainWindow>
	3	#include <qchartview.h>
	4	#include <qlineseries.h>
	5	#include <qareaseries.h>
	6	#include <qchart.h>
	7	#include <qchartaxis.h>
	8	#include <cmath>
	9
	10	QTCOMMERCIALCHART_USE_NAMESPACE
	11
	12	int main(int argc, char *argv[])
	13	{
	14	QApplication a(argc, argv);
	15
	16	//![1]
	17
	18	QLineSeries* series0 = new QLineSeries();
	19	QLineSeries* series1 = new QLineSeries();
	20
	21	//![1]
	22
	23	//![2]
	24	*series0 << QPointF(1, 5) << QPointF(3, 7) << QPointF(7, 6) << QPointF(9, 7) << QPointF(12,6)<<QPointF(16,7)<<QPointF(18,5);
	25	*series1 << QPointF(1, 3) << QPointF(3, 4) << QPointF(7, 3) << QPointF(8, 2) << QPointF(12,3)<<QPointF(16,4)<<QPointF(18,3);
	26	//![2]
	27	//![3]
	28
	29	QAreaSeries* series = new QAreaSeries(series0,series1);
	30	QPen pen(0x059605);
	31	pen.setWidth(3);
	32	series->setPen(pen);
	33
	34	QLinearGradient gradient(QPointF(0, 0), QPointF(0, 1));
	35	gradient.setColorAt(0.0,0x3cc63c);
	36	gradient.setColorAt(1.0, 0x26f626);
	37	gradient.setCoordinateMode(QGradient::ObjectBoundingMode);
	38	series->setBrush(gradient);
	39
	40	//![3]
	41	//![4]
	42	QMainWindow window;
	43	QChartView* chartView = new QChartView(&window);
	44
	45	chartView->setChartTitle("Basic area chart example");
	46	chartView->setRenderHint(QPainter::Antialiasing);
	47
	48	chartView->addSeries(series);
	49	chartView->axisX()->setRange(0,20);
	50	chartView->axisY()->setRange(0,10);
	51	//![4]
	52	//![5]
	53	window.setCentralWidget(chartView);
	54	window.resize(400, 300);
	55	window.show();
	56	//![5]
	57
	58	return a.exec();
	59	}

src/areachart/areachart.pri created 644 +14 0

@@ -0,0 +1,14
	1	INCLUDEPATH += $$PWD
	2	DEPENDPATH += $$PWD
	3
	4	SOURCES += \
	5	#$$PWD/areachartanimationitem.cpp \
	6	$$PWD/areachartitem.cpp \
	7	$$PWD/qareaseries.cpp
	8
	9	PRIVATE_HEADERS += \
	10	$$PWD/areachartitem_p.h \
	11	# $$PWD/linechartanimationitem_p.h
	12
	13	PUBLIC_HEADERS += \
	14	$$PWD/qareaseries.h No newline at end of file

src/areachart/areachartanimationitem.cpp created 644 +63 0

@@ -0,0 +1,63
	1	#include "linechartanimationitem_p.h"
	2	#include "linechartitem_p.h"
	3	#include <QPropertyAnimation>
	4
	5	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	6
	7	const static int duration = 500;
	8
	9
	10	LineChartAnimationItem::LineChartAnimationItem(ChartPresenter* presenter, QLineSeries* series,QGraphicsItem *parent):
	11	LineChartItem(presenter,series,parent)
	12	{
	13
	14	}
	15
	16	LineChartAnimationItem::~LineChartAnimationItem()
	17	{
	18	}
	19
	20	void LineChartAnimationItem::addPoints(const QVector<QPointF>& points)
	21	{
	22	m_data=points;
	23	clearView();
	24	QPropertyAnimation *animation = new QPropertyAnimation(this, "a_addPoints", parent());
	25	animation->setDuration(duration);
	26	//animation->setEasingCurve(QEasingCurve::InOutBack);
	27	animation->setKeyValueAt(0.0, 0);
	28	animation->setKeyValueAt(1.0, m_data.size());
	29	animation->start(QAbstractAnimation::DeleteWhenStopped);
	30	}
	31
	32	void LineChartAnimationItem::setPoint(int index,const QPointF& point)
	33	{
	34	AnimationHelper* helper = new AnimationHelper(this,index);
	35	QPropertyAnimation *animation = new QPropertyAnimation(helper, "point", parent());
	36	animation->setDuration(duration);
	37	//animation->setEasingCurve(QEasingCurve::InOutBack);
	38	animation->setKeyValueAt(0.0, points().value(index));
	39	animation->setKeyValueAt(1.0, point);
	40	animation->start(QAbstractAnimation::DeleteWhenStopped);
	41	}
	42
	43	void LineChartAnimationItem::aw_addPoints(int points)
	44	{
	45	int index = count();
	46	for(int i = index;i< points ;i++){
	47	LineChartItem::addPoint(m_data.at(i));
	48	}
	49	updateGeometry();
	50	update();
	51	}
	52
	53	void LineChartAnimationItem::aw_setPoint(int index,const QPointF& point)
	54	{
	55	LineChartItem::setPoint(index,point);
	56	updateGeometry();
	57	update();
	58	}
	59
	60
	61	#include "moc_linechartanimationitem_p.cpp"
	62
	63	QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/areachartanimationitem_p.h created 644 +55 0

@@ -0,0 +1,55
	1	#ifndef LINECHARTANIMATIONITEM_P_H_
	2	#define LINECHARTANIMATIONITEM_P_H_
	3
	4	#include "qchartglobal.h"
	5	#include "linechartitem_p.h"
	6	#include "domain_p.h"
	7
	8	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	9
	10	class LineChartItem;
	11
	12	class LineChartAnimationItem : public LineChartItem {
	13	Q_OBJECT
	14	Q_PROPERTY(int a_addPoints READ ar_addPoints WRITE aw_addPoints);
	15	// Q_PROPERTY(QPointF a_setPoint READ ar_setPoint WRITE aw_setPoint);
	16	public:
	17	LineChartAnimationItem(ChartPresenter* presenter, QLineSeries series, QGraphicsItem parent = 0);
	18	virtual ~LineChartAnimationItem();
	19
	20	void addPoints(const QVector<QPointF>& points);
	21	void setPoint(int index,const QPointF& point);
	22	//void removePoint(const QPointF& point){};
	23	//void setPoint(const QPointF& oldPoint, const QPointF& newPoint){};
	24
	25	int ar_addPoints() const { return m_addPoints;}
	26	void aw_addPoints(int points);
	27	const QPointF& ar_setPoint() const { return m_setPoint;}
	28	void aw_setPoint(int index,const QPointF& point);
	29
	30	private:
	31	QVector<QPointF> m_data;
	32	Domain m_domain;
	33	int m_addPoints;
	34	QPointF m_setPoint;
	35	int m_setPoint_index;
	36	};
	37
	38	class AnimationHelper: public QObject
	39	{
	40	Q_OBJECT
	41	Q_PROPERTY(QPointF point READ point WRITE setPoint);
	42	public:
	43	AnimationHelper(LineChartAnimationItem* item,int index):m_item(item),m_index(index){};
	44	void setPoint(const QPointF& point){
	45	m_item->aw_setPoint(m_index,point);
	46	}
	47	QPointF point(){return m_point;}
	48	QPointF m_point;
	49	LineChartAnimationItem* m_item;
	50	int m_index;
	51	};
	52
	53	QTCOMMERCIALCHART_END_NAMESPACE
	54
	55	#endif

src/areachart/areachartitem.cpp created 644 +116 0

@@ -0,0 +1,116
	1	#include "areachartitem_p.h"
	2	#include "qareaseries.h"
	3	#include "qlineseries.h"
	4	#include "chartpresenter_p.h"
	5	#include <QPainter>
	6
	7
	8	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	9
	10	//TODO: optimize : remove points which are not visible
	11
	12	AreaChartItem::AreaChartItem(ChartPresenter* presenter, QAreaSeries* areaSeries,QGraphicsItem *parent):ChartItem(parent),
	13	m_presenter(presenter),
	14	m_series(areaSeries),
	15	m_upper(0),
	16	m_lower(0)
	17	{
	18	//m_items.setZValue(ChartPresenter::LineChartZValue);
	19	m_upper = new AreaBoundItem(this,presenter,m_series->upperSeries());
	20	if(m_series->lowerSeries()){
	21	m_lower = new AreaBoundItem(this,presenter,m_series->lowerSeries());
	22	}
	23	setZValue(ChartPresenter::LineChartZValue);
	24
	25	QObject::connect(presenter,SIGNAL(geometryChanged(const QRectF&)),this,SLOT(handleGeometryChanged(const QRectF&)));
	26	QObject::connect(areaSeries,SIGNAL(updated()),this,SLOT(handleUpdated()));
	27
	28	handleUpdated();
	29	}
	30
	31	AreaChartItem::~AreaChartItem()
	32	{
	33	delete m_upper;
	34	delete m_lower;
	35	};
	36
	37	QRectF AreaChartItem::boundingRect() const
	38	{
	39	return m_rect;
	40	}
	41
	42	QPainterPath AreaChartItem::shape() const
	43	{
	44	return m_path;
	45	}
	46
	47	void AreaChartItem::setPen(const QPen& pen)
	48	{
	49	m_pen = pen;
	50	}
	51
	52	void AreaChartItem::setBrush(const QBrush& brush)
	53	{
	54	m_brush = brush;
	55	}
	56
	57	void AreaChartItem::updatePath()
	58	{
	59	QPainterPath path;
	60
	61	path.connectPath(m_upper->shape());
	62	if(m_lower){
	63	path.connectPath(m_lower->shape().toReversed());
	64	}
	65	else{
	66	QPointF first = path.pointAtPercent(0);
	67	QPointF last = path.pointAtPercent(1);
	68	path.lineTo(last.x(),m_clipRect.bottom());
	69	path.lineTo(first.x(),m_clipRect.bottom());
	70	}
	71	path.closeSubpath();
	72	prepareGeometryChange();
	73	m_path=path;
	74	m_rect=path.boundingRect();
	75	update();
	76	}
	77
	78	void AreaChartItem::handleUpdated()
	79	{
	80	setPen(m_series->pen());
	81	setBrush(m_series->brush());
	82	update();
	83	}
	84
	85	void AreaChartItem::handleDomainChanged(const Domain& domain)
	86	{
	87	m_upper->handleDomainChanged(domain);
	88	if(m_lower)
	89	m_lower->handleDomainChanged(domain);
	90	}
	91
	92	void AreaChartItem::handleGeometryChanged(const QRectF& rect)
	93	{
	94	m_clipRect=rect.translated(-rect.topLeft());
	95	setPos(rect.topLeft());
	96	m_upper->handleGeometryChanged(rect);
	97	if(m_lower)
	98	m_lower->handleGeometryChanged(rect);
	99	}
	100	//painter
	101
	102	void AreaChartItem::paint(QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget)
	103	{
	104	Q_UNUSED(widget);
	105	Q_UNUSED(option);
	106	painter->save();
	107	painter->setPen(m_pen);
	108	painter->setBrush(m_brush);
	109	painter->setClipRect(m_clipRect);
	110	painter->drawPath(m_path);
	111	painter->restore();
	112	}
	113
	114	#include "moc_areachartitem_p.cpp"
	115
	116	QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/areachartitem_p.h created 644 +67 0

@@ -0,0 +1,67
	1	#ifndef AREACHARTITEM_H
	2	#define AREACHARTITEM_H
	3
	4	#include "qchartglobal.h"
	5	#include "linechartitem_p.h"
	6	#include <QPen>
	7
	8	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	9
	10	class ChartPresenter;
	11	class QAreaSeries;
	12	class AreaChartItem;
	13
	14	class AreaChartItem : public QObject ,public ChartItem
	15	{
	16	Q_OBJECT
	17	public:
	18	AreaChartItem(ChartPresenter* presenter, QAreaSeries* areaSeries, QGraphicsItem *parent = 0);
	19	~ AreaChartItem();
	20
	21	//from QGraphicsItem
	22	QRectF boundingRect() const;
	23	void paint(QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget);
	24	QPainterPath shape() const;
	25
	26	void setPen(const QPen& pen);
	27	void setBrush(const QBrush& brush);
	28	void setPointsVisible(bool visible);
	29	void updatePath();
	30	public slots:
	31	void handleUpdated();
	32	void handleDomainChanged(const Domain& domain);
	33	void handleGeometryChanged(const QRectF& size);
	34
	35	private:
	36	ChartPresenter* m_presenter;
	37	QPainterPath m_path;
	38	QAreaSeries* m_series;
	39	LineChartItem* m_upper;
	40	LineChartItem* m_lower;
	41	QRectF m_rect;
	42	QRectF m_clipRect;
	43	QPen m_pen;
	44	QBrush m_brush;
	45	};
	46
	47	class AreaBoundItem : public LineChartItem
	48	{
	49	public:
	50	AreaBoundItem(AreaChartItem* item,ChartPresenter* presenter, QLineSeries* lineSeries):LineChartItem(presenter,lineSeries),
	51	m_item(item){};
	52
	53	~AreaBoundItem(){};
	54
	55	void applyGeometry(QVector<QPointF>& points){
	56	LineChartItem::applyGeometry(points);
	57	m_item->updatePath();
	58	}
	59
	60	private:
	61	AreaChartItem* m_item;
	62
	63	};
	64
	65	QTCOMMERCIALCHART_END_NAMESPACE
	66
	67	#endif

src/areachart/qareaseries.cpp created 644 +115 0

@@ -0,0 +1,115
	1	#include "qareaseries.h"
	2	#include "qlineseries.h"
	3
	4	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	5
	6	/*!
	7	\class QAreaSeries
	8	\brief The QAreaSeries class is used for making area charts.
	9
	10	\mainclass
	11
	12	An area chart is used to show quantitative data. It is based on line chart, in the way that area between axis and the line
	13	is emphasized with color. Since the area chart is based on line chart, QAreaSeries constructor needs QLineSeries instance,
	14	which defines "upper" boundary of the area. "Lower" boundary is defined by default by axis X (y=0). Instead of axis X "lower" boundary can be also specified also by other line.
	15	In that case QAreaSeries should be initiated with two QLineSerie instances. Please note terms "upper" and "lower" boundary can be misleading in cases
	16	where "lower" boundary had bigger values than the "upper" one, however the main point that area between these two boundary will be filled.
	17
	18	\image areachart.png
	19
	20	Creating basic area chart is simple:
	21	\code
	22	QLineSeries* lineSeries = new QLineSeries();
	23	series->add(0, 6);
	24	series->add(2, 4);
	25	QAreaSeries* areaSeries = new QAreaSeries(lineSeries);
	26	...
	27	chartView->addSeries(areaSeries);
	28	\endcode
	29	*/
	30
	31	/*!
	32	\fn virtual QSeriesType QAreaSeries::type() const
	33	\brief Returns type of series.
	34	\sa QSeries, QSeriesType
	35	*/
	36
	37	/*!
	38	\fn QLineSeries* QAreaSeries::upperSeries() const
	39	\brief Returns upperSeries used to define one of area boundaries.
	40	*/
	41
	42	/*!
	43	\fn QLineSeries* QAreaSeries::lowerSeries() const
	44	\brief Returns lowerSeries used to define one of area boundaries. Note if QAreaSeries where counstucted wihtout a\ lowerSeries
	45	this function return Null pointer.
	46	*/
	47
	48	/*!
	49	\fn QPen QAreaSeries::pen() const
	50	\brief Returns the pen used to draw line for this series.
	51	\sa setPen()
	52	*/
	53
	54	/*!
	55	\fn QPen QAreaSeries::brush() const
	56	\brief Returns the brush used to draw line for this series.
	57	\sa setBrush()
	58	*/
	59
	60	/*!
	61	\fn bool QAreaSeries::pointsVisible() const
	62	\brief Returns if the points are drawn for this series.
	63	\sa setPointsVisible()
	64	*/
	65
	66	/*!
	67	\fn void QAreaSeries::updated()
	68	\brief \internal
	69	*/
	70
	71	/*!
	72	Constructs area series object which is a child of \a upperSeries. Area will be spanned between \a
	73	upperSeries line and \a lowerSeries line. If no \a lowerSeries is passed to constructor, area is specified by axis x (y=0) instead.
	74	When series object is added to QChartView or QChart instance ownerships is transfered.
	75	*/
	76	QAreaSeries::QAreaSeries(QLineSeries* upperSeries,QLineSeries* lowerSeries):QSeries(upperSeries),
	77	m_upperSeries(upperSeries),
	78	m_lowerSeries(lowerSeries),
	79	m_pointsVisible(false)
	80	{
	81	}
	82	/*!
	83	Destroys the object. Series added to QChartView or QChart instances are owned by those,
	84	and are deleted when mentioned object are destroyed.
	85	*/
	86	QAreaSeries::~QAreaSeries()
	87	{
	88	}
	89
	90	/*!
	91	Sets \a pen used for drawing area outline.
	92	*/
	93	void QAreaSeries::setPen(const QPen& pen)
	94	{
	95	m_pen=pen;
	96	}
	97
	98	/*!
	99	Sets \a brush used for filling the area.
	100	*/
	101	void QAreaSeries::setBrush(const QBrush& brush)
	102	{
	103	m_brush=brush;
	104	}
	105	/*!
	106	Sets if data points are \a visible and should be drawn on line.
	107	*/
	108	void QAreaSeries::setPointsVisible(bool visible)
	109	{
	110	m_pointsVisible=visible;
	111	}
	112
	113	#include "moc_qareaseries.cpp"
	114
	115	QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/qareaseries.h created 644 +48 0

@@ -0,0 +1,48
	1	#ifndef QAREASERIES_H_
	2	#define QAREASERIES_H_
	3
	4	#include "qchartglobal.h"
	5	#include "qseries.h"
	6	#include <QDebug>
	7	#include <QPen>
	8	#include <QBrush>
	9
	10	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	11	class QLineSeries;
	12
	13	class QTCOMMERCIALCHART_EXPORT QAreaSeries : public QSeries
	14	{
	15	Q_OBJECT
	16	public:
	17	QAreaSeries(QLineSeries* upperSeries,QLineSeries* lowerSeries=0);
	18	virtual ~QAreaSeries();
	19
	20	public: // from QChartSeries
	21	virtual QSeriesType type() const { return QSeries::SeriesTypeArea;}
	22
	23	QLineSeries* upperSeries() const { return m_upperSeries;}
	24	QLineSeries* lowerSeries() const { return m_lowerSeries;}
	25
	26	void setPen(const QPen& pen);
	27	QPen pen() const { return m_pen;}
	28
	29	void setBrush(const QBrush& brush);
	30	QBrush brush() const { return m_brush;}
	31
	32	void setPointsVisible(bool visible);
	33	bool pointsVisible() const {return m_pointsVisible;}
	34
	35	signals:
	36	void updated();
	37
	38	private:
	39	QBrush m_brush;
	40	QPen m_pen;
	41	QLineSeries* m_upperSeries;
	42	QLineSeries* m_lowerSeries;
	43	bool m_pointsVisible;
	44	};
	45
	46	QTCOMMERCIALCHART_END_NAMESPACE
	47
	48	#endif

doc/src/classes.qdoc +1 0

             /*!
                 \page classes.html
                 \title QtCommercial Charts API
                 \keyword All Classes
                 \raw HTML
                     <table cellpadding="2" cellspacing="1" border="0" width="100%" class="indextable">
                     <tr>
                     <th class="titleheader" width="33%">
                     List of classes
                     </th>
                     </tr>
                     <tr>
                     <td valign="top">
                     <ul>
+                        <li><a href="qareaseries.html">QAreaSeries</a></li>
                         <li><a href="qbarseries.html">QBarSeries</a></li>
                         <li><a href="qbarset.html">QBarSet</a></li>
                         <li><a href="qchart.html">QChart</a></li>
                         <li><a href="qchartaxis.html">QChartAxis</a></li>
                         <li><a href="qchartview.html">QChartView</a></li>
                         <li><a href="qlineseries.html">QLineSeries</a></li>
                         <li><a href="qpercentbarseries.html">QPercentBarSeries</a></li>
                         <li><a href="qpieseries.html">QPieSeries</a></li>
                         <li><a href="qpieslice.html">QPieSlice</a></li>
                         <li><a href="qscatterseries.html">QScatterSeries</a></li>
                         <li><a href="qseries.html">QSeries</a></li>
                         <li><a href="qstackedbarseries.html">QStackedBarSeries</a></li>
                     </ul>
                     </td>
                     </tr>
                     </table>
                     <table cellpadding="2" cellspacing="1" border="0" width="100%" class="indextable">
                     <tr>
                     <th class="titleheader" width="33%">
                     Other files:
                     </th>
                     </tr>
                     <tr>
                     <td valign="top">
                     <ul>
                         <li><a href="qchartglobal.html">QChartGlobal</a></li>
                     </ul>
                     </td>
                     </tr>
                     </table>
                 \endraw
             */

doc/src/examples.qdoc +1 0

             /*!
                 \page examples.html
                 \title Examples
                 \keyword Examples
                 \raw HTML
                     <table cellpadding="2" cellspacing="1" border="0" width="100%" class="indextable">
                     <tr>
                     <th class="titleheader" width="33%">
                     List of examples
                     </th>
                     </tr>
                     <tr>
                     <td valign="top">
                     <ul>
+                        <li><a href="example-areachart.html">Area Chart example</a></li>
                         <li><a href="example-barchart.html">Bar Chart example</a></li>
                         <li><a href="example-stackedbarchart.html">Stacked Bar Chart example</a></li>
                         <li><a href="example-percentbarchart.html">Percent Bar Chart example</a></li>
                         <li><a href="example-linechart.html">Line Chart example</a></li>
                         <li><a href="example-piechart.html">Pie Chart example</a></li>
                     </ul>
                     </td>
                     </tr>
                     </table>
                 \endraw
             */

doc/src/index.qdoc +4 -3

             /*!
                 \page index.html
                 \keyword About
             	\raw HTML
                 <div class="qchart">
                  <img src="images/qt_commercial_logo.png" alt="qtcommercial"/>
                  <p>
                  QCharts is a part of Qt Commercial addons package. It provides a set of easy to use chart
             	 components which are available for Qt Commercial customers. It uses Qt Graphics View
             	 Framework, therefore charts can be easily integrated to modern 2D user interfaces. QCharts can
             	 be used as QWidgets, QGraphicsWidget or QML elements. Users can easily create impressive
             	 graphs by selecting one of the charts themes.
                  </p>
                 <table><tr>
                 <td><a href="example-linechart.html"><img src="images/linechart.png" alt="linechart" /></a></td>
-                <td><a href="example-barchart.html"><img src="images/barchart.png" alt="barchart" /></a></td>
+                <td><a href="example-areachart.html"><img src="images/areachart.png" alt="areachart" /></a></td>
                 </tr>
                 <tr>
+                <td><a href="example-barchart.html"><img src="images/barchart.png" alt="barchart" /></a></td>
                 <td><a href="example-percentbarchart.html"><img src="images/percentbarchart.png" alt="percentbarcchart" /></a></td>
-                <td><a href="example-stackedbarchart.html"><img src="images/stackedbarchart.png" alt="stackedbarchart" /></a></td>
                 </tr>
                 <tr>
+                <td><a href="example-stackedbarchart.html"><img src="images/stackedbarchart.png" alt="stackedbarchart" /></a></td>
                 <td><img src="images/chartview_example.jpg " alt="linechart" /></td>
-                <td><img src="images/chartview_example_pie.jpg " alt="piechart" /></td>
                 </tr><tr>
                 <td><img src="images/chartview_example_scatter.jpg " alt="scatterchart" /></td>
                 <td><img src="images/chartview_example_theme.jpg " alt="themechart" /></td>
                 </tr>
                 <tr>
                 <td><img src="images/chartview_example_bar.jpg " alt="barchart" /></td>
+                <td><img src="images/chartview_example_pie.jpg " alt="piechart" /></td>
                 </tr>
                 </table>
                  </div>
             	\endraw
             */

example/example.pro +2 -1

             TEMPLATE = subdirs
             SUBDIRS += linechart \
                        zoomlinechart \
                        colorlinechart \
                        barchart \
                        stackedbarchart \
                        percentbarchart \
                        scatter \
                        piechart \
                        piechartdrilldown \
                        dynamiclinechart \
                        axischart \
                        multichart \
                        gdpbarchart \
                        presenterchart \
                        chartview \
-                       scatterinteractions
+                       scatterinteractions \
+                       areachart

src/chartdataset.cpp +33 -4

             #include "chartdataset_p.h"
             #include "qchartaxis.h"
             //series
             #include "qlineseries.h"
+            #include "qareaseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
             m_axisX(new QChartAxis(this)),
             m_axisY(new QChartAxis(this)),
             m_domainIndex(0),
             m_axisXInitialized(false)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
                 // TODO Auto-generated destructor stub
             }
             const Domain ChartDataSet::domain(QChartAxis *axisY) const
             {
                 int i = m_domainMap.count(axisY);
                 if(i == 0) {
                     return Domain();
                 }
                 i = i - m_domainIndex -1;
                 return m_domainMap.values(axisY).at(i);
             }
             void ChartDataSet::addSeries(QSeries* series, QChartAxis *axisY)
             {
                 // TODO: we should check the series not already added
                 series->setParent(this);// take ownership
                 clearDomains();
                 if(axisY==0) axisY = m_axisY;
                 axisY->setParent(this);// take ownership
                 QList<QSeries*> seriesList = m_seriesMap.values(axisY);
                 QList<Domain> domainList = m_domainMap.values(axisY);
                 Q_ASSERT(domainList.size()<=1);
                 Domain domain;
                 if(domainList.size()>0) domain = domainList.at(0);
                 switch(series->type())
                 {
                     case QSeries::SeriesTypeLine: {
-                        QLineSeries* xyseries = static_cast<QLineSeries*>(series);
+                        QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
-                        for (int i = 0; i < xyseries->count(); i++)
+                        for (int i = 0; i < lineSeries->count(); i++)
                         {
-                            qreal x = xyseries->x(i);
+                            qreal x = lineSeries->x(i);
-                            qreal y = xyseries->y(i);
+                            qreal y = lineSeries->y(i);
                             domain.m_minX = qMin(domain.m_minX,x);
                             domain.m_minY = qMin(domain.m_minY,y);
                             domain.m_maxX = qMax(domain.m_maxX,x);
                             domain.m_maxY = qMax(domain.m_maxY,y);
                         }
                         break;
                     }
+                    case QSeries::SeriesTypeArea: {
+                        QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
+                        QLineSeries* upperSeries = areaSeries->upperSeries();
+                        QLineSeries* lowerSeries = areaSeries->lowerSeries();
+                        for (int i = 0; i <  upperSeries->count(); i++)
+                        {
+                            qreal x =  upperSeries->x(i);
+                            qreal y =  upperSeries->y(i);
+                            domain.m_minX = qMin(domain.m_minX,x);
+                            domain.m_minY = qMin(domain.m_minY,y);
+                            domain.m_maxX = qMax(domain.m_maxX,x);
+                            domain.m_maxY = qMax(domain.m_maxY,y);
+                        }
+                        if(lowerSeries){
+                        for (int i = 0; i < lowerSeries->count(); i++)
+                        {
+                            qreal x = lowerSeries->x(i);
+                            qreal y = lowerSeries->y(i);
+                            domain.m_minX = qMin(domain.m_minX,x);
+                            domain.m_minY = qMin(domain.m_minY,y);
+                            domain.m_maxX = qMax(domain.m_maxX,x);
+                            domain.m_maxY = qMax(domain.m_maxY,y);
+                        }}
+                        break;
+                    }
                     case QSeries::SeriesTypeBar: {
                         qDebug() << "QChartSeries::SeriesTypeBar";
                         QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                         qreal x = barSeries->categoryCount();
                         qreal y = barSeries->max();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                         break;
                     }
                     case QSeries::SeriesTypeStackedBar: {
                         qDebug() << "QChartSeries::SeriesTypeStackedBar";
                         QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                         qreal x = stackedBarSeries->categoryCount();
                         qreal y = stackedBarSeries->maxCategorySum();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                         break;
                     }
                     case QSeries::SeriesTypePercentBar: {
                         qDebug() << "QChartSeries::SeriesTypePercentBar";
                         QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                         qreal x = percentBarSeries->categoryCount();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = 0;
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = 100;
                         break;
                     }
                     case QSeries::SeriesTypePie: {
                         QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                         // TODO: domain stuff
                         break;
                     }
                     case QSeries::SeriesTypeScatter: {
                         QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                         Q_ASSERT(scatterSeries);
                         foreach (QPointF point, scatterSeries->data()) {
                             domain.m_minX = qMin(domain.m_minX, point.x());
                             domain.m_maxX = qMax(domain.m_maxX, point.x());
                             domain.m_minY = qMin(domain.m_minY, point.y());
                             domain.m_maxY = qMax(domain.m_maxY, point.y());
                         }
                         break;
                     }
                     default: {
                         qDebug()<<__FUNCTION__<<"type" << series->type()<<"not supported";
                         return;
                         break;
                     }
                 }
                 if(!m_domainMap.contains(axisY))
                 {
                     emit axisAdded(axisY);
                     QObject::connect(axisY,SIGNAL(rangeChanged(QChartAxis*)),this,SLOT(handleRangeChanged(QChartAxis*)));
                     QObject::connect(axisY,SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
                 }
                 if(!m_axisXInitialized)
                 {
                     emit axisAdded(axisX());
                     QObject::connect(axisX(),SIGNAL(rangeChanged(QChartAxis*)),this,SLOT(handleRangeChanged(QChartAxis*)));
                     QObject::connect(axisX(),SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
                     m_axisXInitialized=true;
                 }
                 m_domainMap.replace(axisY,domain);
                 m_seriesMap.insert(axisY,series);
                 emit seriesAdded(series);
                 setDomain(m_domainIndex,axisY);
             }
             void ChartDataSet::removeSeries(QSeries* series)
             {
                 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
                 foreach(QChartAxis* axis , keys) {
                     if(m_seriesMap.contains(axis,series)) {
                         emit seriesRemoved(series);
                         m_seriesMap.remove(axis,series);
                         //remove axis if no longer there
                         if(!m_seriesMap.contains(axis)) {
                             emit axisRemoved(axis);
                             m_domainMap.remove(axis);
                             if(axis != m_axisY)
                             delete axis;
                         }
                         series->setParent(0);
                         break;
                     }
                 }
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
                 foreach(QChartAxis* axis , keys) {
                     QList<QSeries*> seriesList = m_seriesMap.values(axis);
                     for(int i =0; i < seriesList.size();i++ )
                     {
                         emit seriesRemoved(seriesList.at(i));
                         delete(seriesList.at(i));
                     }
                     m_seriesMap.remove(axis);
                     m_domainMap.remove(axis);
                     emit axisRemoved(axis);
                     if(axis != m_axisY) delete axis;
                 }
                 m_domainIndex=0;
             }
             bool ChartDataSet::nextDomain()
             {
                 int limit = (m_domainMap.values().size()/m_domainMap.uniqueKeys().size())-1;
                 if (m_domainIndex < limit) {
                     m_domainIndex++;
                     setDomain(m_domainIndex);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             bool ChartDataSet::previousDomain()
             {
                 if (m_domainIndex > 0) {
                     m_domainIndex--;
                     setDomain(m_domainIndex);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             void ChartDataSet::setDomain(int index)
             {
                 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
                 if(domainList.count()==0) return;
                 Domain domain;
                 foreach (QChartAxis* axis , domainList) {
                     int i = m_domainMap.count(axis) - index -1;
                     Q_ASSERT(i>=0);
                     domain = m_domainMap.values(axis).at(i);
                     QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
                     QList<QSeries*> seriesList = m_seriesMap.values(axis);
                     foreach(QSeries* series, seriesList) {
                         emit seriesDomainChanged(series,domain);
                     }
                     axis->updateRange(domain.m_minY,domain.m_maxY);
                     emit axisRangeChanged(axis,labels);
                 }
                 QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
                 axisX()->updateRange(domain.m_minX,domain.m_maxY);
                 emit axisRangeChanged(axisX(),labels);
             }
             void ChartDataSet::setDomain(int index,QChartAxis* axis)
             {
                 int i = m_domainMap.count(axis) - index -1;
                 Q_ASSERT(i>=0);
                 Domain domain = m_domainMap.values(axis).at(i);
                 {
                     QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
                     QList<QSeries*> seriesList = m_seriesMap.values(axis);
                     foreach(QSeries* series, seriesList) {
                         emit seriesDomainChanged(series,domain);
                     }
                     axis->updateRange(domain.m_minY,domain.m_maxY);
                     emit axisRangeChanged(axis,labels);
                 }
                 QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
                 axisX()->updateRange(domain.m_minX,domain.m_maxY);
                 emit axisRangeChanged(axisX(),labels);
             }
             void ChartDataSet::clearDomains(int toIndex)
             {
                 Q_ASSERT(toIndex>=0);
                 m_domainIndex = toIndex;
                 QList<QChartAxis*> keys = m_domainMap.uniqueKeys();
                 foreach (QChartAxis* key , keys)
                 {
                     QList<Domain> domains = m_domainMap.values(key);
                     m_domainMap.remove(key);
                     int i = domains.size() - toIndex - 1;
                     while(i--) {
                         domains.removeFirst();
                     }
                     for(int j=domains.size()-1; j>=0;j--)
                     m_domainMap.insert(key,domains.at(j));
                 }
             }
             void ChartDataSet::addDomain(const QRectF& rect, const QRectF& viewport)
             {
                 Q_ASSERT(rect.isValid());
                 Q_ASSERT(viewport.isValid());
                 clearDomains(m_domainIndex);
                 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
                 Domain domain;
                 foreach (QChartAxis* axis , domainList) {
                     domain = m_domainMap.value(axis).subDomain(rect,viewport.width(),viewport.height());
                     m_domainMap.insert(axis,domain);
                 }
                 setDomain(++m_domainIndex);
             }
             QChartAxis* ChartDataSet::axisY(QSeries* series) const
             {
                 if(series == 0) return m_axisY;
                 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
                 foreach(QChartAxis* axis , keys) {
                     if(m_seriesMap.contains(axis,series)) {
                         return axis;
                     }
                 }
                 return 0;
             }
             QStringList ChartDataSet::createLabels(QChartAxis* axis,qreal min, qreal max)
             {
                 Q_ASSERT(max>=min);
                 QStringList labels;
                 int ticks = axis->ticksCount()-1;
                 for(int i=0; i<= ticks; i++) {
                     qreal value = min + (i * (max - min)/ ticks);
                     QString label = axis->axisTickLabel(value);
                     if(label.isEmpty()) {
                         labels << QString::number(value);
                     }
                     else {
                         labels << label;
                     }
                 }
                 return labels;
             }
             void ChartDataSet::handleRangeChanged(QChartAxis* axis)
             {
                 qreal min = axis->min();
                 qreal max = axis->max();
                 if(axis==axisX()) {
                     m_domainIndex=0;
                     clearDomains(m_domainIndex);
                     QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
                     foreach (QChartAxis* axis , domainList) {
                         Q_ASSERT(m_domainMap.values(axis).size()==1);
                         Domain domain = m_domainMap.value(axis);
                         domain.m_minX=min;
                         domain.m_maxX=max;
                         m_domainMap.replace(axis,domain);
                     }
                     setDomain(m_domainIndex);
                 }
                 else {
                     QList<Domain> domains = m_domainMap.values(axis);
                     m_domainMap.remove(axis);
                     for(int i=0;i<domains.size();i++)
                     {
                         domains[i].m_minY=min;
                         domains[i].m_maxY=max;
                     }
                     for(int j=domains.size()-1; j>=0;j--)
                     m_domainMap.insert(axis,domains.at(j));
                     setDomain(m_domainIndex,axis);
                 }
             }
             void ChartDataSet::handleTickChanged(QChartAxis* axis)
             {
                 if(axis==axisX()) {
                     Domain domain = m_domainMap.value(axisY());
                     QStringList labels = createLabels(axis,domain.m_minX,domain.m_maxX);
                     emit axisRangeChanged(axis,labels);
                 }
                 else {
                     Domain domain = m_domainMap.value(axis);
                     QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
                     emit axisRangeChanged(axis,labels);
                 }
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +19 -6

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             //series
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
+            #include "qareaseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             //items
             #include "axisitem_p.h"
             #include "axisanimationitem_p.h"
+            #include "areachartitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
             #include "linechartanimationitem_p.h"
             #include "piepresenter_p.h"
             #include "scatterpresenter_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_dataset(dataset),
             m_chartTheme(0),
             m_marginSize(0),
             m_rect(QRectF(QPoint(0,0),m_chart->size())),
             m_options(0)
             {
             	createConnections();
                 setChartTheme(QChart::ChartThemeDefault);
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QSeries*)),this,SLOT(handleSeriesAdded(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*)),this,SLOT(handleAxisAdded(QChartAxis*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
                 QObject::connect(m_dataset,SIGNAL(seriesDomainChanged(QSeries*,const Domain&)),this,SLOT(handleSeriesDomainChanged(QSeries*,const Domain&)));
                 QObject::connect(m_dataset,SIGNAL(axisRangeChanged(QChartAxis*,const QStringList&)),this,SLOT(handleAxisRangeChanged(QChartAxis*,const QStringList&)));
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 m_rect = QRectF(QPoint(0,0),m_chart->size());
                 m_rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 Q_ASSERT(m_rect.isValid());
                 emit geometryChanged(m_rect);
             }
             int ChartPresenter::margin() const
             {
                 return m_marginSize;
             }
             void ChartPresenter::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void ChartPresenter::handleAxisAdded(QChartAxis* axis)
             {
                 AxisItem* item ;
                 if(!m_options.testFlag(QChart::GridAxisAnimations))
                 {
                     item = new AxisItem(axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }else{
                     item = new AxisAnimationItem(axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 QObject::connect(axis,SIGNAL(update(QChartAxis*)),item,SLOT(handleAxisUpdate(QChartAxis*)));
                 item->handleAxisUpdate(axis);
                 item->handleGeometryChanged(m_rect);
                 m_chartTheme->decorate(axis,item);
                 m_axisItems.insert(axis,item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 AxisItem* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QSeries* series)
             {
                 switch(series->type())
                 {
                     case QSeries::SeriesTypeLine: {
                         QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                         LineChartItem* item;
                         if(m_options.testFlag(QChart::SeriesAnimations)){
                             item = new LineChartAnimationItem(this,lineSeries,m_chart);
                         }else{
                             item = new LineChartItem(this,lineSeries,m_chart);
                         }
                         m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
-                        QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
-                        QObject::connect(lineSeries,SIGNAL(pointReplaced(int)),item,SLOT(handlePointReplaced(int)));
-                        QObject::connect(lineSeries,SIGNAL(pointAdded(int)),item,SLOT(handlePointAdded(int)));
-                        QObject::connect(lineSeries,SIGNAL(pointRemoved(int)),item,SLOT(handlePointRemoved(int)));
-                        QObject::connect(lineSeries,SIGNAL(updated()),item,SLOT(handleUpdated()));
                         m_chartItems.insert(series,item);
                         if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
-                        item->handleUpdated();
+                        break;
+                    }
+                    case QSeries::SeriesTypeArea: {
+                        QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
+                        AreaChartItem* item;
+                        if(m_options.testFlag(QChart::SeriesAnimations)) {
+                            item = new AreaChartItem(this,areaSeries,m_chart);
+                        }
+                        else {
+                            item = new AreaChartItem(this,areaSeries,m_chart);
+                        }
+                        m_chartTheme->decorate(item,areaSeries,m_chartItems.count());
+                        m_chartItems.insert(series,item);
+                        if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                         break;
                     }
                     case QSeries::SeriesTypeBar: {
                         QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                         BarPresenter* item = new BarPresenter(barSeries,m_chart);
                         m_chartTheme->decorate(item,barSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(barSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         // m_axisXItem->setVisible(false);
                         if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                         break;
                     }
                     case QSeries::SeriesTypeStackedBar: {
                         QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                         StackedBarPresenter* item = new StackedBarPresenter(stackedBarSeries,m_chart);
                         m_chartTheme->decorate(item,stackedBarSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(stackedBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                         break;
                     }
                     case QSeries::SeriesTypePercentBar: {
                         QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                         PercentBarPresenter* item = new PercentBarPresenter(percentBarSeries,m_chart);
                         m_chartTheme->decorate(item,percentBarSeries ,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(percentBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                         break;
                     }
                     case QSeries::SeriesTypeScatter: {
                         QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                         ScatterPresenter *scatterPresenter = new ScatterPresenter(scatterSeries, m_chart);
                         QObject::connect(scatterPresenter, SIGNAL(clicked(QPointF)),
                                          scatterSeries, SIGNAL(clicked(QPointF)));
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
                                          scatterPresenter, SLOT(handleGeometryChanged(const QRectF&)));
                         m_chartTheme->decorate(scatterPresenter, scatterSeries, m_chartItems.count());
                         m_chartItems.insert(scatterSeries, scatterPresenter);
                         if(m_rect.isValid()) scatterPresenter->handleGeometryChanged(m_rect);
                         break;
                     }
                     case QSeries::SeriesTypePie: {
                         QPieSeries *s = qobject_cast<QPieSeries *>(series);
                         PiePresenter* pie = new PiePresenter(m_chart, s);
                         m_chartTheme->decorate(pie, s, m_chartItems.count());
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
                         // Hide all from background when there is only piechart
                         // TODO: refactor this ugly code... should be one setting for this
                         if (m_chartItems.count() == 0) {
                             m_chart->axisX()->setAxisVisible(false);
                             m_chart->axisY()->setAxisVisible(false);
                             m_chart->axisX()->setGridVisible(false);
                             m_chart->axisY()->setGridVisible(false);
                             m_chart->axisX()->setLabelsVisible(false);
                             m_chart->axisY()->setLabelsVisible(false);
                             m_chart->axisX()->setShadesVisible(false);
                             m_chart->axisY()->setShadesVisible(false);
                             m_chart->setChartBackgroundBrush(Qt::transparent);
                         }
                         m_chartItems.insert(series, pie);
                         pie->handleGeometryChanged(m_rect);
                         break;
                     }
                     default: {
                         qDebug()<< "Series type" << series->type() << "not implemented.";
                         break;
                     }
                 }
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
             	ChartItem* item = m_chartItems.take(series);
             	delete item;
             }
             void ChartPresenter::handleSeriesDomainChanged(QSeries* series, const Domain& domain)
             {
                 m_chartItems.value(series)->handleDomainChanged(domain);
             }
             void ChartPresenter::handleAxisRangeChanged(QChartAxis* axis,const QStringList& labels)
             {
                 m_axisItems.value(axis)->handleRangeChanged(axis,labels);
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
             {
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
                 QMapIterator<QSeries*,ChartItem*> i(m_chartItems);
                 int index=0;
                 while (i.hasNext()) {
                     i.next();
                     m_chartTheme->decorate(i.value(),i.key(),index);
                     index++;
                 }
                 QMapIterator<QChartAxis*,AxisItem*> j(m_axisItems);
                 while (j.hasNext()) {
                         j.next();
                         m_chartTheme->decorate(j.key(),j.value());
                 }
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     //recreate elements
                     QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
                     QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
                     foreach(QChartAxis* axis, axisList) {
                         handleAxisRemoved(axis);
                         handleAxisAdded(axis);
                     }
                     foreach(QSeries* series, seriesList) {
                         handleSeriesRemoved(series);
                         handleSeriesAdded(series);
                     }
                     //now reintialize view data
                     //TODO: make it more nice
                     m_dataset->setDomain(m_dataset->domainIndex());
                 }
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +31 -1

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
+            #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             //items
             #include "axisitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
+            #include "areachartitem_p.h"
             #include "scatterpresenter_p.h"
             #include "piepresenter_p.h"
             //themes
             #include "chartthemevanilla_p.h"
             #include "chartthemeicy_p.h"
             #include "chartthemegrayscale_p.h"
             #include "chartthemescientific_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /* TODO
                 case QChart::ChartThemeUnnamed1:
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff3fa9f5)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff7AC943)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF931E)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF1D25)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF7BAC)), 2));
                     m_gradientStartColor = QColor(QRgb(0xfff3dc9e));
                     m_gradientEndColor = QColor(QRgb(0xffafafaf));
             */
             ChartTheme::ChartTheme(QChart::ChartTheme id)
             {
                 m_id = id;
                 m_seriesColor.append(QRgb(0xff000000));
                 m_seriesColor.append(QRgb(0xff707070));
                 m_gradientStartColor = QColor(QRgb(0xffffffff));
                 m_gradientEndColor = QColor(QRgb(0xffafafaf));
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeDefault:
-                        return new ChartThemeIcy();
+                        return new ChartTheme();
                     case QChart::ChartThemeVanilla:
                         return new ChartThemeVanilla();
                     case QChart::ChartThemeIcy:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeGrayscale:
                         return new ChartThemeGrayscale();
                     case QChart::ChartThemeScientific:
                         return new ChartThemeScientific();
                 }
             }
             void ChartTheme::decorate(QChart* chart)
             {
                 QLinearGradient backgroundGradient;
                 backgroundGradient.setColorAt(0.0, m_gradientStartColor);
                 backgroundGradient.setColorAt(1.0, m_gradientEndColor);
                 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                 chart->setChartBackgroundBrush(backgroundGradient);
             }
             //TODO helper to by removed later
             void ChartTheme::decorate(ChartItem* item, QSeries* series,int count)
             {
                 switch(series->type())
                 {
                     case QSeries::SeriesTypeLine: {
                         QLineSeries* s = static_cast<QLineSeries*>(series);
                         LineChartItem* i = static_cast<LineChartItem*>(item);
                         decorate(i,s,count);
                         break;
                     }
+                    case QSeries::SeriesTypeArea: {
+                               QAreaSeries* s = static_cast<QAreaSeries*>(series);
+                               AreaChartItem* i = static_cast<AreaChartItem*>(item);
+                               decorate(i,s,count);
+                               break;
+                    }
                     case QSeries::SeriesTypeBar: {
                         QBarSeries* b = static_cast<QBarSeries*>(series);
                         BarPresenter* i = static_cast<BarPresenter*>(item);
                         decorate(i,b,count);
                         break;
                     }
                     case QSeries::SeriesTypeStackedBar: {
                         QStackedBarSeries* s = static_cast<QStackedBarSeries*>(series);
                         StackedBarPresenter* i = static_cast<StackedBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QSeries::SeriesTypePercentBar: {
                         QPercentBarSeries* s = static_cast<QPercentBarSeries*>(series);
                         PercentBarPresenter* i = static_cast<PercentBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QSeries::SeriesTypeScatter: {
                         QScatterSeries* s = qobject_cast<QScatterSeries*>(series);
                         Q_ASSERT(s);
                         ScatterPresenter* i = static_cast<ScatterPresenter*>(item);
                         Q_ASSERT(i);
                         decorate(i, s, count);
                         break;
                     }
                     case QSeries::SeriesTypePie: {
                         QPieSeries* s = static_cast<QPieSeries*>(series);
                         PiePresenter* i = static_cast<PiePresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     default:
                     qDebug()<<"Wrong item to be decorated by theme";
                     break;
                 }
             }
+            void ChartTheme::decorate(AreaChartItem* item, QAreaSeries* series,int count)
+            {
+                QPen pen;
+                QBrush brush;
+                if(pen != series->pen()){
+                   item->setPen(series->pen());
+                }else{
+                    pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
+                    pen.setWidthF(2);
+                    item->setPen(pen);
+                }
+                if(brush != series->brush()){
+                   item->setBrush(series->brush());
+                }else{
+                   QBrush brush(m_seriesColor.at(count%m_seriesColor.size()));
+                   item->setBrush(brush);
+                }
+            }
             void ChartTheme::decorate(LineChartItem* item, QLineSeries* series,int count)
             {
                 QPen pen;
                 if(pen != series->pen()){
                     item->setPen(series->pen());
                     return;
                 }
                 pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
                 pen.setWidthF(2);
                 item->setPen(pen);
             }
             void ChartTheme::decorate(BarPresenter* item, QBarSeries* series,int count)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<series->barsetCount(); i++) {
                     sets.at(i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(StackedBarPresenter* item, QStackedBarSeries* series,int count)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<series->barsetCount(); i++) {
                     sets.at(i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(PercentBarPresenter* item, QPercentBarSeries* series,int count)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<series->barsetCount(); i++) {
                     sets.at(i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(ScatterPresenter* presenter, QScatterSeries* series, int count)
             {
                 Q_ASSERT(presenter);
                 Q_ASSERT(series);
                 QColor color = m_seriesColor.at(count % m_seriesColor.size());
                 // TODO: define alpha in the theme? or in the series?
                 //color.setAlpha(120);
                 QBrush brush(color, Qt::SolidPattern);
                 presenter->m_markerBrush = brush;
                 QPen pen(brush, 3);
                 pen.setColor(color);
                 presenter->m_markerPen = pen;
             }
             void ChartTheme::decorate(PiePresenter* item, QPieSeries* series, int /*count*/)
             {
                 // create a list of slice colors based on current theme
                 int i = 0;
                 QList<QColor> colors;
                 while (colors.count() < series->count()) {
                     // get base color
                     QColor c = m_seriesColor[i++];
                     i = i % m_seriesColor.count();
                     // dont use black colors... looks bad
                     if (c == Qt::black)
                         continue;
                     // by default use the "raw" theme color
                     if (!colors.contains(c)) {
                         colors << c;
                         continue;
                     }
                     // ...ok we need to generate something that looks like the same color
                     // but different lightness
                     int tryCount = 0;
                     while (tryCount++ < 100) {
                         // find maximum value we can raise the lightness
                         int lMax = 255;
                         if (lMax > 255 - c.red())
                             lMax = 255 - c.red();
                         if (lMax > 255 - c.green())
                             lMax = 255 - c.green();
                         if (lMax > 255 - c.blue())
                             lMax = 255 - c.blue();
                         // find maximum value we can make it darker
                         int dMax = 255;
                         if (dMax > c.red())
                             dMax = c.red();
                         if (dMax > c.green())
                             dMax = c.green();
                         if (dMax > c.blue())
                             dMax = c.blue();
                         int max = dMax + lMax;
                         if (max == 0) {
                             // no room to make color lighter or darker...
                             qDebug() << "cannot generate a color for pie!";
                             break;
                         }
                         // generate random color
                         int r = c.red() - dMax;
                         int g = c.green() - dMax;
                         int b = c.blue() - dMax;
                         int d = qrand() % max;
                         c.setRgb(r+d, g+d, b+d);
                         // found a unique color?
                         if (!colors.contains(c))
                             break;
                     }
                     qDebug() << "generated a color for pie" << c;
                     colors << c;
                 }
                 // finally update colors
                 foreach (QPieSlice* s, series->slices()) {
                     QColor c = colors.takeFirst();
                     s->setPen(c);
                     s->setBrush(c);
                 }
             }
             void ChartTheme::decorate(QChartAxis* axis,AxisItem* item)
             {
                 //TODO: dummy defults for now
                 axis->setLabelsBrush(Qt::black);
                 axis->setLabelsPen(Qt::NoPen);
                 axis->setShadesPen(Qt::NoPen);
                 axis->setShadesOpacity(0.5);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme_p.h +4 -1

             #ifndef CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class QSeries;
             class LineChartItem;
             class QLineSeries;
             class BarPresenter;
             class QBarSeries;
             class StackedBarPresenter;
             class QStackedBarSeries;
             class QPercentBarSeries;
             class PercentBarPresenter;
             class QScatterSeries;
             class ScatterPresenter;
             class PiePresenter;
             class QPieSeries;
+            class AreaChartItem;
+            class QAreaSeries;
             class ChartTheme
             {
             protected:
                 explicit ChartTheme(QChart::ChartTheme id =  QChart::ChartThemeDefault);
             public:
                 static ChartTheme* createTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme id() const {return m_id;}
                 void decorate(QChart* chart);
                 void decorate(ChartItem* item, QSeries* series,int count);
                 void decorate(BarPresenter* item, QBarSeries* series,int count);
                 void decorate(StackedBarPresenter* item, QStackedBarSeries* series,int count);
                 void decorate(PercentBarPresenter* item, QPercentBarSeries* series,int count);
-                void decorate(LineChartItem* item, QLineSeries*, int count);
+                void decorate(LineChartItem* item, QLineSeries* series,int count);
+                void decorate(AreaChartItem* item, QAreaSeries* series,int count);
                 void decorate(ScatterPresenter* presenter, QScatterSeries* series, int count);
                 void decorate(PiePresenter* item, QPieSeries* series, int count);
                 void decorate(QChartAxis* axis,AxisItem* item);
             protected:
                 QChart::ChartTheme m_id;
                 QColor m_gradientStartColor;
                 QColor m_gradientEndColor;
                 QList<QColor> m_seriesColor;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/linechart/linechartitem.cpp +6 0

             #include "linechartitem_p.h"
             #include "qlineseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             LineChartItem::LineChartItem(ChartPresenter* presenter, QLineSeries* series,QGraphicsItem *parent):ChartItem(parent),
             m_presenter(presenter),
             m_series(series),
             m_items(this)
             {
             	//m_items.setZValue(ChartPresenter::LineChartZValue);
                 setZValue(ChartPresenter::LineChartZValue);
+                QObject::connect(presenter,SIGNAL(geometryChanged(const QRectF&)),this,SLOT(handleGeometryChanged(const QRectF&)));
+                QObject::connect(series,SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
+                QObject::connect(series,SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
+                QObject::connect(series,SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
+                QObject::connect(series,SIGNAL(updated()),this,SLOT(handleUpdated()));
             }
             QRectF LineChartItem::boundingRect() const
             {
             	return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_path;
             }
             void LineChartItem::createPoints(int count)
             {
                 for (int i = 0; i < count; ++i) {
                     QGraphicsRectItem* item = new QGraphicsRectItem(0,0,3,3);
                     m_items.addToGroup(item);
                 }
             }
             void LineChartItem::clearPoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     delete(items.takeLast());
                 }
             }
             QPointF LineChartItem::calculateGeometryPoint(int index) const
             {
                 const qreal deltaX = m_size.width()/m_domain.spanX();
                 const qreal deltaY = m_size.height()/m_domain.spanY();
                 qreal x = (m_series->x(index) - m_domain.m_minX)* deltaX;
                 qreal y = (m_series->y(index) - m_domain.m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QVector<QPointF> LineChartItem::calculateGeometryPoints() const
             {
                 const qreal deltaX = m_size.width()/m_domain.spanX();
                 const qreal deltaY = m_size.height()/m_domain.spanY();
                 QVector<QPointF> points;
                 points.reserve(m_series->count());
                 for (int i = 0; i < m_series->count(); ++i) {
                   qreal x = (m_series->x(i) - m_domain.m_minX)* deltaX;
                   qreal y = (m_series->y(i) - m_domain.m_minY)*-deltaY + m_size.height();
                   points << QPointF(x,y);
                 }
                 return points;
             }
             void LineChartItem::updateItem(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints)
             {
             	applyGeometry(newPoints);
             	oldPoints = newPoints;
             }
             void LineChartItem::updateItem(QVector<QPointF>& oldPoints,int index,QPointF& newPoint)
             {
             	oldPoints.replace(index,newPoint);
             	applyGeometry(oldPoints);
             }
             void LineChartItem::applyGeometry(QVector<QPointF>& points)
             {
                if(points.size()==0) return;
                QList<QGraphicsItem*> items = m_items.childItems();
                QPainterPath path;
                const QPointF& point = points.at(0);
                path.moveTo(point);
                QGraphicsItem* item = items.at(0);
                item->setPos(point.x()-1,point.y()-1);
                if(!m_clipRect.contains(point)) item->setVisible(false);
                for(int i=1 ; i< points.size();i++) {
                    QGraphicsItem* item = items.at(i);
                    const QPointF& point = points.at(i);
                    item->setPos(point.x()-1,point.y()-1);
                    if(!m_clipRect.contains(point)) item->setVisible(false);
                    path.lineTo(point);
                }
                prepareGeometryChange();
                m_path = path;
                m_rect = path.boundingRect();
             }
             void LineChartItem::setPen(const QPen& pen)
             {
                 m_pen = pen;
             }
             //handlers
             void LineChartItem::handlePointAdded(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QPointF point = calculateGeometryPoint(index);
                 createPoints(1);
                 QVector<QPointF> points = m_points;
                 points.insert(index,point);
                 updateItem(m_points,points);
                 update();
             }
             void LineChartItem::handlePointRemoved(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QPointF point = calculateGeometryPoint(index);
                 clearPoints(1);
                 QVector<QPointF> points = m_points;
                 points.remove(index);
                 updateItem(m_points,points);
                 update();
             }
             void LineChartItem::handlePointReplaced(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QPointF point = calculateGeometryPoint(index);
                 updateItem(m_points,index,point);
                 update();
             }
             void LineChartItem::handleDomainChanged(const Domain& domain)
             {
                 m_domain = domain;
                 if(m_domain.isEmpty()) return;
                 if(!m_clipRect.isValid()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 int diff = m_points.size() - points.size();
                 if(diff>0) {
                       clearPoints(diff);
                 }
                 else if(diff<0) {
                      createPoints(-diff);
                 }
                 updateItem(m_points,points);
                 update();
             }
             void LineChartItem::handleGeometryChanged(const QRectF& rect)
             {
             	Q_ASSERT(rect.isValid());
             	m_size=rect.size();
             	m_clipRect=rect.translated(-rect.topLeft());
             	setPos(rect.topLeft());
             	if(m_domain.isEmpty()) return;
             	QVector<QPointF> points = calculateGeometryPoints();
             	int diff = m_points.size() - points.size();
             	if(diff>0) {
             		clearPoints(diff);
             	}
             	else if(diff<0) {
             		createPoints(-diff);
             	}
             	updateItem(m_points,points);
             	update();
             }
             void LineChartItem::handleUpdated()
             {
                 m_items.setVisible(m_series->pointsVisible());
                 setPen(m_series->pen());
                 update();
             }
             //painter
             void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget);
                 Q_UNUSED(option);
                 painter->save();
                 painter->setPen(m_pen);
                 painter->setClipRect(m_clipRect);
                 painter->drawPath(m_path);
                 painter->restore();
             }
             #include "moc_linechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartitem_p.h +1 -1

             #ifndef LINECHARTITEM_H
             #define LINECHARTITEM_H
             #include "qchartglobal.h"
             #include "chartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QLineSeries;
             class LineChartItem :  public QObject , public ChartItem
             {
                  Q_OBJECT
             public:
                 LineChartItem(ChartPresenter* presenter, QLineSeries* series,QGraphicsItem *parent = 0);
                 ~ LineChartItem(){};
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
                 void setPen(const QPen& pen);
                 void setPointsVisible(bool visible);
             public slots:
                 void handlePointAdded(int index);
                 void handlePointRemoved(int index);
                 void handlePointReplaced(int index);
                 void handleUpdated();
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& size);
             public:
                 virtual void updateItem(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints);
                 virtual void updateItem(QVector<QPointF>& oldPoints,int index,QPointF& newPoint);
-                void applyGeometry(QVector<QPointF>& points);
+                virtual void applyGeometry(QVector<QPointF>& points);
                 void createPoints(int count);
                 void clearPoints(int count);
                 QPointF calculateGeometryPoint(int index) const;
                 QVector<QPointF> calculateGeometryPoints() const;
             private:
                 ChartPresenter* m_presenter;
                 QPainterPath m_path;
                 QLineSeries* m_series;
                 QSizeF m_size;
                 QRectF m_rect;
                 QRectF m_clipRect;
                 Domain m_domain;
                 QGraphicsItemGroup m_items;
                 QVector<QPointF> m_points;
                 QPen m_pen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/src.pro +1 0

             !include( ../common.pri ):error( Couldn't find the common.pri file! )
             TARGET = QtCommercialChart
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT += core \
                 gui
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QtCommercialChartd
             SOURCES += axisitem.cpp \
                 axisanimationitem.cpp \
                 chartdataset.cpp \
                 chartpresenter.cpp \
                 charttheme.cpp \
                 domain.cpp \
                 qchart.cpp \
                 qchartaxis.cpp \
                 qchartview.cpp \
                 qseries.cpp
             PRIVATE_HEADERS += axisitem_p.h \
                 axisanimationitem_p.h \
                 chartdataset_p.h \
                 chartitem_p.h \
                 chartpresenter_p.h \
                 charttheme_p.h \
                 domain_p.h
             PUBLIC_HEADERS += qchart.h \
                 qchartaxis.h \
                 qchartglobal.h \
                 qseries.h \
                 qchartview.h
             include(linechart/linechart.pri)
+            include(areachart/areachart.pri)
             include(barchart/barchart.pri)
             include(piechart/piechart.pri)
             include(scatterseries/scatter.pri)
             THEMES += themes/chartthemeicy_p.h \
                 themes/chartthemegrayscale_p.h \
                 themes/chartthemescientific_p.h \
                 themes/chartthemevanilla_p.h
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             INCLUDEPATH += linechart \
                 barchart \
                 themes \
                 .
             OBJECTS_DIR = $$CHART_BUILD_DIR/lib
             MOC_DIR = $$CHART_BUILD_DIR/lib
             UI_DIR = $$CHART_BUILD_DIR/lib
             RCC_DIR = $$CHART_BUILD_DIR/lib
             DEFINES += QTCOMMERCIALCHART_LIBRARY
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target \
                 public_headers
             install_build_public_headers.name = bild_public_headers
             install_build_public_headers.output = $$CHART_BUILD_PUBLIC_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_public_headers.input = PUBLIC_HEADERS
             install_build_public_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PUBLIC_HEADER_DIR
             install_build_public_headers.CONFIG += target_predeps \
                 no_link
             install_build_private_headers.name = bild_private_headers
             install_build_private_headers.output = $$CHART_BUILD_PRIVATE_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_private_headers.input = PRIVATE_HEADERS
             install_build_private_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PRIVATE_HEADER_DIR
             install_build_private_headers.CONFIG += target_predeps \
                 no_link
             QMAKE_EXTRA_COMPILERS += install_build_public_headers \
                 install_build_private_headers
             chartversion.target = qchartversion_p.h
             chartversion.commands = @echo \
                 "build_time" \
                 > \
                 $$chartversion.target;
             chartversion.depends = $$HEADERS \
                 $$SOURCES
             PRE_TARGETDEPS += qchartversion_p.h
             QMAKE_CLEAN += qchartversion_p.h
             QMAKE_EXTRA_TARGETS += chartversion
             unix:QMAKE_DISTCLEAN += -r \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             win32:QMAKE_DISTCLEAN += /Q \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR

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