HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1534:d9bcc3bd9d82

Refactors layout managment...

Michal Klocek -

r1534:d9bcc3bd9d82

parent child

Context file:

r1534:d9bcc3bd9d82

Expand all files

src/chartlayout.cpp created 644 +144 0

@@ -0,0 +1,144
	1	#include "chartlayout_p.h"
	2	#include "chartpresenter_p.h"
	3	#include "chartaxis_p.h"
	4	#include <QDebug>
	5	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	6
	7	ChartLayout::ChartLayout(ChartPresenter* presenter):
	8	m_presenter(presenter),
	9	m_marginBig(60),
	10	m_marginSmall(20),
	11	m_marginTiny(10),
	12	m_chartMargins(QPointF(m_marginBig,m_marginBig),QPointF(m_marginBig,m_marginBig))
	13	{
	14
	15	}
	16
	17	ChartLayout::~ChartLayout()
	18	{
	19
	20	}
	21
	22	void ChartLayout::setGeometry(const QRectF& rect)
	23	{
	24	if (!rect.isValid()) return;
	25
	26	QGraphicsLayout::setGeometry(rect);
	27
	28	// check title size
	29
	30	QSize titleSize = QSize(0,0);
	31
	32	if (m_presenter->titleItem()) {
	33	titleSize= m_presenter->titleItem()->boundingRect().size().toSize();
	34	}
	35
	36	qreal axisHeight = 0;
	37	qreal axisWidth = 0;
	38
	39	// check axis size
	40
	41	foreach (ChartAxis* axis,m_presenter->axisItems()){
	42	if(axis->axisType() == ChartAxis::X_AXIS)
	43	axisHeight = qMax(axis->minimumHeight(),axisHeight);
	44	else
	45	axisWidth = qMax(axis->minimumWidth(),axisWidth);
	46	}
	47
	48	QLegend* legend = m_presenter->legend();
	49
	50	qreal titlePadding = m_chartMargins.top()/2;
	51
	52	QRectF chartMargins = m_chartMargins;
	53
	54	// recalculate legend position
	55	if (legend != 0 && legend->isVisible() && legend->isAttachedToChart()) {
	56
	57	// Reserve some space for legend
	58	switch (legend->alignment()) {
	59
	60	case Qt::AlignTop: {
	61	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(rect.width(),-1));
	62	int topMargin = 2*m_marginTiny + titleSize.height() + legendSize.height() + m_marginTiny;
	63	chartMargins = QRect(QPoint(m_chartMargins.left(),topMargin),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
	64	m_legendMargins = QRect(QPoint(chartMargins.left(),topMargin - (legendSize.height() + m_marginTiny)),QPoint(chartMargins.right(),rect.height()-topMargin + m_marginTiny));
	65	titlePadding = m_marginTiny + m_marginTiny;
	66	break;
	67	}
	68	case Qt::AlignBottom: {
	69	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(rect.width(),-1));
	70	int bottomMargin = m_marginTiny + m_marginSmall + legendSize.height() + m_marginTiny + axisHeight;
	71	chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(m_chartMargins.right(),bottomMargin));
	72	m_legendMargins = QRect(QPoint(chartMargins.left(),rect.height()-bottomMargin + m_marginTiny + axisHeight),QPoint(chartMargins.right(),m_marginTiny + m_marginSmall));
	73	titlePadding = chartMargins.top()/2;
	74	break;
	75	}
	76	case Qt::AlignLeft: {
	77	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(-1,rect.height()));
	78	int leftPadding = m_marginTiny + m_marginSmall + legendSize.width() + m_marginTiny + axisWidth;
	79	chartMargins = QRect(QPoint(leftPadding,m_chartMargins.top()),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
	80	m_legendMargins = QRect(QPoint(m_marginTiny + m_marginSmall,chartMargins.top()),QPoint(rect.width()-leftPadding + m_marginTiny + axisWidth,chartMargins.bottom()));
	81	titlePadding = chartMargins.top()/2;
	82	break;
	83	}
	84	case Qt::AlignRight: {
	85	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(-1,rect.height()));
	86	int rightPadding = m_marginTiny + m_marginSmall + legendSize.width() + m_marginTiny;
	87	chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(rightPadding,m_chartMargins.bottom()));
	88	m_legendMargins = QRect(QPoint(rect.width()- rightPadding+ m_marginTiny ,chartMargins.top()),QPoint(m_marginTiny + m_marginSmall,chartMargins.bottom()));
	89	titlePadding = chartMargins.top()/2;
	90	break;
	91	}
	92	default: {
	93	break;
	94	}
	95	}
	96
	97	legend->setGeometry(rect.adjusted(m_legendMargins.left(),m_legendMargins.top(),-m_legendMargins.right(),-m_legendMargins.bottom()));
	98	}
	99
	100	// recalculate title position
	101	if (m_presenter->titleItem()) {
	102	QPointF center = rect.center() - m_presenter->titleItem()->boundingRect().center();
	103	m_presenter->titleItem()->setPos(center.x(),titlePadding);
	104	}
	105
	106	//recalculate background gradient
	107	if (m_presenter->backgroundItem()) {
	108	m_presenter->backgroundItem()->setRect(rect.adjusted(m_marginTiny,m_marginTiny, -m_marginTiny, -m_marginTiny));
	109	}
	110
	111	QRectF chartRect = rect.adjusted(chartMargins.left(),chartMargins.top(),-chartMargins.right(),-chartMargins.bottom());
	112
	113	if(m_presenter->geometry()!=chartRect && chartRect.isValid()){
	114	m_presenter->setGeometry(chartRect);
	115	}else if(chartRect.size().isEmpty()){
	116	m_presenter->setGeometry(QRect(rect.width()/2,rect.height()/2,1,1));
	117	}
	118
	119	}
	120
	121
	122	QSizeF ChartLayout::sizeHint ( Qt::SizeHint which, const QSizeF & constraint) const
	123	{
	124	Q_UNUSED(constraint);
	125	if(which == Qt::MinimumSize)
	126	return QSize(2(m_chartMargins.top()+m_chartMargins.bottom()),2(m_chartMargins.top() + m_chartMargins.bottom()));
	127	else
	128	return QSize(-1,-1);
	129	}
	130
	131	void ChartLayout::setMarginsMinimum(const QRectF& margins)
	132	{
	133	if(m_chartMargins != margins){
	134	m_chartMargins = margins;
	135	updateGeometry();
	136	}
	137	}
	138
	139	QRectF ChartLayout::margins() const
	140	{
	141	return m_chartMargins;
	142	}
	143
	144	QTCOMMERCIALCHART_END_NAMESPACE

src/chartlayout_p.h created 644 +43 0

@@ -0,0 +1,43
	1	#ifndef CHARTLAYOUT_H_
	2	#define CHARTLAYOUT_H_
	3	#include <QGraphicsLayout>
	4	#include "qchartglobal.h"
	5
	6	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	7
	8	class ChartPresenter;
	9
	10	class ChartLayout : public QGraphicsLayout
	11	{
	12	public:
	13
	14	ChartLayout(ChartPresenter* presenter);
	15	virtual ~ChartLayout();
	16
	17	void setMarginsMinimum(const QRectF& margins);
	18	QRectF margins() const;
	19
	20	void setGeometry(const QRectF& rect);
	21
	22	protected:
	23	QSizeF sizeHint ( Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const;
	24	int count() const { return 0; }
	25	QGraphicsLayoutItem* itemAt(int) const { return 0; };
	26	void removeAt(int){};
	27
	28	private:
	29	ChartPresenter* m_presenter;
	30	int m_marginBig;
	31	int m_marginSmall;
	32	int m_marginTiny;
	33
	34	QRectF m_chartMargins;
	35	QRectF m_legendMargins;
	36
	37
	38
	39	};
	40
	41	QTCOMMERCIALCHART_END_NAMESPACE
	42
	43	#endif

src/legend/legendlayout.cpp created 644 +348 0

@@ -0,0 +1,348
	1	#include "legendlayout_p.h"
	2	#include "chartpresenter_p.h"
	3	#include "legendmarker_p.h"
	4	#include "qlegend_p.h"
	5	#include <QDebug>
	6	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	7
	8	LegendLayout::LegendLayout(QLegend* legend):
	9	m_legend(legend)
	10	{
	11
	12	}
	13
	14	LegendLayout::~LegendLayout()
	15	{
	16
	17	}
	18
	19	void LegendLayout::setOffset(qreal x, qreal y)
	20	{
	21	bool scrollHorizontal = true;
	22	switch(m_legend->alignment()) {
	23	case Qt::AlignTop:
	24	case Qt::AlignBottom: {
	25	scrollHorizontal = true;
	26	break;
	27	}
	28	case Qt::AlignLeft:
	29	case Qt::AlignRight: {
	30	scrollHorizontal = false;
	31	break;
	32	}
	33	}
	34
	35	// If detached, the scrolling direction is vertical instead of horizontal and vice versa.
	36	if (!m_legend->isAttachedToChart()) {
	37	scrollHorizontal = !scrollHorizontal;
	38	}
	39
	40	QRectF boundingRect = geometry();
	41
	42	// Limit offset between m_minOffset and m_maxOffset
	43	if (scrollHorizontal) {
	44	if(m_width<=boundingRect.width()) return;
	45
	46	if (x != m_offsetX) {
	47	m_offsetX = qBound(m_minOffsetX, x, m_maxOffsetX);
	48	m_legend->d_ptr->items()->setPos(-m_offsetX,boundingRect.top());
	49	}
	50	}
	51	else {
	52	if(m_height<=boundingRect.height()) return;
	53
	54	if (y != m_offsetY) {
	55	m_offsetY = qBound(m_minOffsetY, y, m_maxOffsetY);
	56	m_legend->d_ptr->items()->setPos(boundingRect.left(),-m_offsetY);
	57	}
	58	}
	59	}
	60
	61	QPointF LegendLayout::offset() const
	62	{
	63	return QPointF(m_offsetX,m_offsetY);
	64	}
	65
	66	void LegendLayout::setGeometry(const QRectF& rect)
	67	{
	68	if (!rect.isValid()) return;
	69
	70	QGraphicsLayout::setGeometry(rect);
	71
	72	if(m_legend->isAttachedToChart()) {
	73	setAttachedGeometry(rect);
	74	}
	75	else {
	76	setDettachedGeometry(rect);
	77	}
	78	}
	79
	80	void LegendLayout::setAttachedGeometry(const QRectF& rect)
	81	{
	82
	83	m_offsetX=0;
	84	m_offsetY=0;
	85
	86	QSizeF size(0,0);
	87
	88	if( m_legend->d_ptr->markers().isEmpty()) return;
	89
	90	m_width=0;
	91	m_height=0;
	92
	93	switch(m_legend->alignment()) {
	94
	95	case Qt::AlignTop:
	96
	97	case Qt::AlignBottom: {
	98	QPointF point(0,0);
	99	foreach (LegendMarker* marker, m_legend->d_ptr->markers()) {
	100	if (marker->isVisible()) {
	101	marker->setGeometry(QRectF(QPoint(0,0),marker->effectiveSizeHint(Qt::PreferredSize)));
	102	marker->setPos(point.x(),rect.height()/2 - marker->boundingRect().height()/2);
	103	const QRectF& rect = marker->boundingRect();
	104	size = size.expandedTo(rect.size());
	105	qreal w = rect.width();
	106	m_width+=w;
	107	point.setX(point.x() + w);
	108	}
	109	}
	110	if(m_width<rect.width()) {
	111	m_legend->d_ptr->items()->setPos(rect.width()/2-m_width/2,rect.top());
	112
	113	}
	114	else {
	115	m_legend->d_ptr->items()->setPos(rect.topLeft());
	116	}
	117	m_height=size.height();
	118	}
	119	break;
	120	case Qt::AlignLeft:
	121	case Qt::AlignRight: {
	122	QPointF point(0,0);
	123	foreach (LegendMarker* marker, m_legend->d_ptr->markers()) {
	124	if (marker->isVisible()) {
	125	marker->setGeometry(QRectF(QPoint(0,0),marker->effectiveSizeHint(Qt::PreferredSize)));
	126	marker->setPos(point);
	127	const QRectF& rect = marker->boundingRect();
	128	qreal h = rect.height();
	129	size = size.expandedTo(rect.size());
	130	m_height+=h;
	131	point.setY(point.y() + h);
	132	}
	133	}
	134	if(m_height<rect.height()) {
	135	m_legend->d_ptr->items()->setPos(rect.left(),rect.height()/2-m_height/2);
	136	}
	137	else {
	138	m_legend->d_ptr->items()->setPos(rect.topLeft());
	139	}
	140	m_width=size.width();
	141	}
	142	break;
	143	}
	144
	145	m_minOffsetX = 0;
	146	m_minOffsetY = 0;
	147	m_maxOffsetX = m_width - rect.width();
	148	m_maxOffsetY = m_height - rect.height();
	149	}
	150
	151	void LegendLayout::setDettachedGeometry(const QRectF& rect)
	152	{
	153	// Detached layout is different.
	154	// In detached mode legend may have multiple rows and columns, so layout calculations
	155	// differ a log from attached mode.
	156	// Also the scrolling logic is bit different.
	157
	158	m_offsetX=0;
	159	m_offsetY=0;
	160
	161	QSizeF size(0,0);
	162
	163	if( m_legend->d_ptr->markers().isEmpty()) return;
	164
	165	QList<QGraphicsItem *> items = m_legend->d_ptr->items()->childItems();
	166
	167	switch (m_legend->alignment()) {
	168	case Qt::AlignTop: {
	169	QPointF point = rect.topLeft();
	170	m_width = 0;
	171	m_height = 0;
	172	for (int i=0; i<items.count(); i++) {
	173	QGraphicsItem *item = items.at(i);
	174	if (item->isVisible()) {
	175	const QRectF& boundingRect = item->boundingRect();
	176	qreal w = boundingRect.width();
	177	qreal h = boundingRect.height();
	178	m_width = qMax(m_width,w);
	179	m_height = qMax(m_height,h);
	180	item->setPos(point.x(),point.y());
	181	point.setX(point.x() + w);
	182	if (point.x() + w > rect.topLeft().x() + rect.width()) {
	183	// Next item would go off rect.
	184	point.setX(rect.topLeft().x());
	185	point.setY(point.y() + h);
	186	if (i+1 < items.count()) {
	187	m_height += h;
	188	}
	189	}
	190	}
	191	}
	192	m_legend->d_ptr->items()->setPos(rect.topLeft());
	193
	194	m_minOffsetX = 0;
	195	m_minOffsetY = 0;
	196	m_maxOffsetX = m_width - rect.width();
	197	m_maxOffsetY = m_height - rect.height();
	198	}
	199	break;
	200	case Qt::AlignBottom: {
	201	QPointF point = rect.bottomLeft();
	202	m_width = 0;
	203	m_height = 0;
	204	for (int i=0; i<items.count(); i++) {
	205	QGraphicsItem *item = items.at(i);
	206	if (item->isVisible()) {
	207	const QRectF& boundingRect = item->boundingRect();
	208	qreal w = boundingRect.width();
	209	qreal h = boundingRect.height();
	210	m_width = qMax(m_width,w);
	211	m_height = qMax(m_height,h);
	212	item->setPos(point.x(),point.y() - h);
	213	point.setX(point.x() + w);
	214	if (point.x() + w > rect.bottomLeft().x() + rect.width()) {
	215	// Next item would go off rect.
	216	point.setX(rect.bottomLeft().x());
	217	point.setY(point.y() - h);
	218	if (i+1 < items.count()) {
	219	m_height += h;
	220	}
	221	}
	222	}
	223	}
	224	m_legend->d_ptr->items()->setPos(rect.topLeft());
	225
	226	m_minOffsetX = 0;
	227	m_minOffsetY = qMin(rect.topLeft().y(), rect.topLeft().y() - m_height + rect.height());
	228	m_maxOffsetX = m_width - rect.width();
	229	m_maxOffsetY = 0;
	230	}
	231	break;
	232	case Qt::AlignLeft: {
	233	QPointF point = rect.topLeft();
	234	m_width = 0;
	235	m_height = 0;
	236	qreal maxWidth = 0;
	237	for (int i=0; i<items.count(); i++) {
	238	QGraphicsItem *item = items.at(i);
	239	if (item->isVisible()) {
	240	const QRectF& boundingRect = item->boundingRect();
	241	qreal w = boundingRect.width();
	242	qreal h = boundingRect.height();
	243	m_height = qMax(m_height,h);
	244	maxWidth = qMax(maxWidth,w);
	245	item->setPos(point.x(),point.y());
	246	point.setY(point.y() + h);
	247	if (point.y() + h > rect.topLeft().y() + rect.height()) {
	248	// Next item would go off rect.
	249	point.setX(point.x() + maxWidth);
	250	point.setY(rect.topLeft().y());
	251	if (i+1 < items.count()) {
	252	m_width += maxWidth;
	253	maxWidth = 0;
	254	}
	255	}
	256	}
	257	}
	258	m_width += maxWidth;
	259	m_legend->d_ptr->items()->setPos(rect.topLeft());
	260
	261	m_minOffsetX = 0;
	262	m_minOffsetY = 0;
	263	m_maxOffsetX = m_width - rect.width();
	264	m_maxOffsetY = m_height - rect.height();
	265	}
	266	break;
	267	case Qt::AlignRight: {
	268	QPointF point = rect.topRight();
	269	m_width = 0;
	270	m_height = 0;
	271	qreal maxWidth = 0;
	272	for (int i=0; i<items.count(); i++) {
	273	QGraphicsItem *item = items.at(i);
	274	if (item->isVisible()) {
	275	const QRectF& boundingRect = item->boundingRect();
	276	qreal w = boundingRect.width();
	277	qreal h = boundingRect.height();
	278	m_height = qMax(m_height,h);
	279	maxWidth = qMax(maxWidth,w);
	280	item->setPos(point.x() - w,point.y());
	281	point.setY(point.y() + h);
	282	if (point.y() + h > rect.topLeft().y() + rect.height()) {
	283	// Next item would go off rect.
	284	point.setX(point.x() - maxWidth);
	285	point.setY(rect.topLeft().y());
	286	if (i+1 < items.count()) {
	287	m_width += maxWidth;
	288	maxWidth = 0;
	289	}
	290	}
	291	}
	292	}
	293	m_width += maxWidth;
	294	m_legend->d_ptr->items()->setPos(rect.topLeft());
	295
	296	m_minOffsetX = qMin(rect.topLeft().x(), rect.topLeft().x() - m_width + rect.width());
	297	m_minOffsetY = 0;
	298	m_maxOffsetX = 0;
	299	m_maxOffsetY = m_height - rect.height();
	300	}
	301	break;
	302	default:
	303	break;
	304	}
	305
	306	}
	307
	308	QSizeF LegendLayout::sizeHint ( Qt::SizeHint which, const QSizeF & constraint) const
	309	{
	310	QSizeF size(0, 0);
	311	qreal left, top, right, bottom;
	312	getContentsMargins(&left, &top, &right, &bottom);
	313
	314	if(constraint.isValid()) {
	315	foreach(LegendMarker* marker, m_legend->d_ptr->markers()) {
	316	size = size.expandedTo(marker->effectiveSizeHint(which));
	317	}
	318	size = size.boundedTo(constraint);
	319	}
	320	else if (constraint.width() >= 0) {
	321	qreal width = 0;
	322	qreal height = 0;
	323	foreach(LegendMarker* marker, m_legend->d_ptr->markers()) {
	324	width+=marker->effectiveSizeHint(which).width();
	325	height=qMax(height,marker->effectiveSizeHint(which).height());
	326	}
	327
	328	size = QSizeF(qMin(constraint.width(),width), height);
	329	}
	330	else if (constraint.height() >= 0) {
	331	qreal width = 0;
	332	qreal height = 0;
	333	foreach(LegendMarker* marker, m_legend->d_ptr->markers()) {
	334	width=qMax(width,marker->effectiveSizeHint(which).width());
	335	height+=height,marker->effectiveSizeHint(which).height();
	336	}
	337	size = QSizeF(width,qMin(constraint.height(),height));
	338	}
	339	else {
	340	foreach(LegendMarker* marker, m_legend->d_ptr->markers()) {
	341	size = size.expandedTo(marker->effectiveSizeHint(which));
	342	}
	343	}
	344	size += QSize(left + right, top + bottom);
	345	return size;
	346	}
	347
	348	QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendlayout_p.h created 644 +50 0

@@ -0,0 +1,50
	1	#ifndef LEGENDLAYOUT_H_
	2	#define LEGENDLAYOUT_H_
	3	#include <QGraphicsLayout>
	4	#include "qchartglobal.h"
	5
	6	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	7
	8	class QLegend;
	9
	10	class LegendLayout : public QGraphicsLayout
	11	{
	12	public:
	13
	14	LegendLayout(QLegend* legend);
	15	virtual ~LegendLayout();
	16
	17	void setGeometry(const QRectF& rect);
	18
	19	void setOffset(qreal x, qreal y);
	20	QPointF offset() const;
	21
	22	protected:
	23	QSizeF sizeHint ( Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const;
	24	int count() const { return 0; }
	25	QGraphicsLayoutItem* itemAt(int) const { return 0; };
	26	void removeAt(int){};
	27
	28	private:
	29	void setAttachedGeometry(const QRectF& rect);
	30	void setDettachedGeometry(const QRectF& rect);
	31
	32	private:
	33	QLegend* m_legend;
	34	int m_marginBig;
	35	int m_marginSmall;
	36	int m_marginTiny;
	37	qreal m_offsetX;
	38	qreal m_offsetY;
	39	qreal m_minOffsetX;
	40	qreal m_minOffsetY;
	41	qreal m_maxOffsetX;
	42	qreal m_maxOffsetY;
	43	qreal m_width;
	44	qreal m_height;
	45
	46	};
	47
	48	QTCOMMERCIALCHART_END_NAMESPACE
	49
	50	#endif

examples/legend/mainwidget.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "mainwidget.h"
             #include <QChart>
             #include <QChartView>
             #include <QPushButton>
             #include <QLabel>
             #include <QDebug>
             #include <QBarSet>
             #include <QBarSeries>
             #include <QLegend>
             #include <QFormLayout>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent)
             {
                 // Create buttons for ui
                 m_buttonLayout = new QGridLayout();
                 QPushButton *detachLegendButton = new QPushButton("detach legend");
                 connect(detachLegendButton, SIGNAL(clicked()), this, SLOT(detachLegend()));
                 m_buttonLayout->addWidget(detachLegendButton, 0, 0);
                 QPushButton *attachLegendButton = new QPushButton("attach legend");
                 connect(attachLegendButton, SIGNAL(clicked()), this, SLOT(attachLegend()));
                 m_buttonLayout->addWidget(attachLegendButton, 1, 0);
                 QPushButton *addSetButton = new QPushButton("add barset");
                 connect(addSetButton, SIGNAL(clicked()), this, SLOT(addBarset()));
                 m_buttonLayout->addWidget(addSetButton, 2, 0);
                 QPushButton *removeBarsetButton = new QPushButton("remove barset");
                 connect(removeBarsetButton, SIGNAL(clicked()), this, SLOT(removeBarset()));
                 m_buttonLayout->addWidget(removeBarsetButton, 3, 0);
                 QPushButton *leftButton = new QPushButton("Align legend left");
                 connect(leftButton, SIGNAL(clicked()), this, SLOT(setLegendLeft()));
                 m_buttonLayout->addWidget(leftButton, 4, 0);
                 QPushButton *rightButton = new QPushButton("Align legend right");
                 connect(rightButton, SIGNAL(clicked()), this, SLOT(setLegendRight()));
                 m_buttonLayout->addWidget(rightButton, 5, 0);
                 QPushButton *topButton = new QPushButton("Align legend top");
                 connect(topButton, SIGNAL(clicked()), this, SLOT(setLegendTop()));
                 m_buttonLayout->addWidget(topButton, 6, 0);
                 QPushButton *bottomButton = new QPushButton("Align legend bottom");
                 connect(bottomButton, SIGNAL(clicked()), this, SLOT(setLegendBottom()));
                 m_buttonLayout->addWidget(bottomButton, 7, 0);
                 QPushButton *boldButton = new QPushButton("Toggle bold");
                 connect(boldButton, SIGNAL(clicked()), this, SLOT(toggleBold()));
                 m_buttonLayout->addWidget(boldButton, 8, 0);
                 QPushButton *italicButton = new QPushButton("Toggle italic");
                 connect(italicButton, SIGNAL(clicked()), this, SLOT(toggleItalic()));
                 m_buttonLayout->addWidget(italicButton, 9, 0);
                 m_legendPosX = new QDoubleSpinBox();
                 m_legendPosY = new QDoubleSpinBox();
                 m_legendWidth = new QDoubleSpinBox();
                 m_legendHeight = new QDoubleSpinBox();
                 connect(m_legendPosX, SIGNAL(valueChanged(double)), this, SLOT(updateLegendLayout()));
                 connect(m_legendPosY, SIGNAL(valueChanged(double)), this, SLOT(updateLegendLayout()));
                 connect(m_legendWidth, SIGNAL(valueChanged(double)), this, SLOT(updateLegendLayout()));
                 connect(m_legendHeight, SIGNAL(valueChanged(double)), this, SLOT(updateLegendLayout()));
                 QFormLayout* legendLayout = new QFormLayout();
                 legendLayout->addRow("Horizontal position", m_legendPosX);
                 legendLayout->addRow("Vertical position", m_legendPosY);
                 legendLayout->addRow("Width", m_legendWidth);
                 legendLayout->addRow("Height", m_legendHeight);
                 m_legendSettings = new QGroupBox("Detached legend");
                 m_legendSettings->setLayout(legendLayout);
                 m_buttonLayout->addWidget(m_legendSettings);
                 m_legendSettings->setVisible(false);
                 // Create chart view with the chart
                 m_chart = new QChart();
                 m_chartView = new QChartView(m_chart, this);
                 // Create spinbox to modify font size
                 m_fontSize = new QDoubleSpinBox();
                 m_fontSize->setValue(m_chart->legend()->font().pointSizeF());
                 connect(m_fontSize, SIGNAL(valueChanged(double)), this, SLOT(fontSizeChanged()));
                 QFormLayout* fontLayout = new QFormLayout();
                 fontLayout->addRow("Legend font size", m_fontSize);
                 // Create layout for grid and detached legend
                 m_mainLayout = new QGridLayout();
                 m_mainLayout->addLayout(m_buttonLayout, 0, 0);
                 m_mainLayout->addLayout(fontLayout,1,0);
                 m_mainLayout->addWidget(m_chartView, 0, 1, 3, 1);
                 setLayout(m_mainLayout);
                 createSeries();
             }
             void MainWidget::createSeries()
             {
                 m_series = new QBarSeries();
                 addBarset();
                 addBarset();
                 addBarset();
                 addBarset();
                 m_chart->addSeries(m_series);
                 m_chart->setTitle("Legend detach example");
             //![1]
                 m_chart->legend()->setVisible(true);
                 m_chart->legend()->setAlignment(Qt::AlignBottom);
             //![1]
                 m_chart->axisY()->setNiceNumbersEnabled(true);
                 m_chartView->setRenderHint(QPainter::Antialiasing);
             }
             void MainWidget::showLegendSpinbox()
             {
                 m_legendSettings->setVisible(true);
                 QRectF chartViewRect = m_chartView->rect();
                 m_legendPosX->setMinimum(0);
                 m_legendPosX->setMaximum(chartViewRect.width());
                 m_legendPosX->setValue(150);
                 m_legendPosY->setMinimum(0);
                 m_legendPosY->setMaximum(chartViewRect.height());
                 m_legendPosY->setValue(150);
                 m_legendWidth->setMinimum(0);
                 m_legendWidth->setMaximum(chartViewRect.width());
                 m_legendWidth->setValue(150);
                 m_legendHeight->setMinimum(0);
                 m_legendHeight->setMaximum(chartViewRect.height());
                 m_legendHeight->setValue(75);
             }
             void MainWidget::hideLegendSpinbox()
             {
                 m_legendSettings->setVisible(false);
             }
             void MainWidget::detachLegend()
             {
             //![2]
                 QLegend *legend = m_chart->legend();
                 legend->detachFromChart();
                 m_chart->legend()->setBackgroundVisible(true);
                 m_chart->legend()->setBrush(QBrush(QColor(128,128,128,128)));
                 m_chart->legend()->setPen(QPen(QColor(192,192,192,192)));
             //![2]
                 showLegendSpinbox();
                 updateLegendLayout();
                 update();
             }
             void MainWidget::attachLegend()
             {
             //![3]
                 QLegend *legend = m_chart->legend();
                 legend->attachToChart();
                 m_chart->legend()->setBackgroundVisible(false);
             //![3]
                 hideLegendSpinbox();
                 update();
             }
             void MainWidget::addBarset()
             {
                 QBarSet *barSet = new QBarSet(QString("set ") + QString::number(m_series->count()));
                 qreal delta = m_series->count() * 0.1;
                 *barSet << QPointF(0.0 + delta, 1 + delta) << QPointF(1.0 + delta, 2 + delta) << QPointF(2.0 + delta, 3 + delta) << QPointF(3.0 + delta, 4 + delta);
                 m_series->append(barSet);
             }
             void MainWidget::removeBarset()
             {
                 QList<QBarSet*> sets = m_series->barSets();
                 if (sets.count() > 0) {
                     m_series->remove(sets.at(sets.count()-1));
                 }
             }
             void MainWidget::setLegendLeft()
             {
                 m_chart->legend()->setAlignment(Qt::AlignLeft);
             }
             void MainWidget::setLegendRight()
             {
                 m_chart->legend()->setAlignment(Qt::AlignRight);
             }
             void MainWidget::setLegendTop()
             {
                 m_chart->legend()->setAlignment(Qt::AlignTop);
             }
             void MainWidget::setLegendBottom()
             {
                 m_chart->legend()->setAlignment(Qt::AlignBottom);
             }
             void MainWidget::toggleBold()
             {
                 QFont font = m_chart->legend()->font();
                 font.setBold(!font.bold());
                 m_chart->legend()->setFont(font);
             }
             void MainWidget::toggleItalic()
             {
                 QFont font = m_chart->legend()->font();
                 font.setItalic(!font.italic());
                 m_chart->legend()->setFont(font);
             }
             void MainWidget::fontSizeChanged()
             {
                 QFont font = m_chart->legend()->font();
                 font.setPointSizeF(m_fontSize->value());
                 m_chart->legend()->setFont(font);
             }
             void MainWidget::updateLegendLayout()
             {
             //![4]
-                m_chart->legend()->setGeometry(m_legendPosX->value()
+                m_chart->legend()->setGeometry(QRectF(m_legendPosX->value()
                                                ,m_legendPosY->value()
                                                ,m_legendWidth->value()
-                                               ,m_legendHeight->value());
+                                               ,m_legendHeight->value()));
                 m_chart->legend()->update();
             //![4]
             }

src/axis/chartaxis.cpp +21 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartaxis_p.h"
             #include "qaxis.h"
             #include "qaxis_p.h"
             #include "qaxiscategories_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QDebug>
             #include <cmath>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxis::ChartAxis(QAxis *axis,ChartPresenter *presenter) : Chart(presenter),
                 m_chartAxis(axis),
                 m_labelsAngle(0),
                 m_grid(new QGraphicsItemGroup(presenter->rootItem())),
                 m_shades(new QGraphicsItemGroup(presenter->rootItem())),
                 m_labels(new QGraphicsItemGroup(presenter->rootItem())),
                 m_axis(new QGraphicsItemGroup(presenter->rootItem())),
                 m_min(0),
                 m_max(0),
                 m_ticksCount(0),
-                m_animation(0)
+                m_animation(0),
+                m_minWidth(0),
+                m_minHeight(0)
             {
                 //initial initialization
                 m_axis->setZValue(ChartPresenter::AxisZValue);
                 m_axis->setHandlesChildEvents(false);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 QObject::connect(m_chartAxis->d_ptr.data(),SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
                 QObject::connect(m_chartAxis->categories()->d_ptr.data(),SIGNAL(updated()),this,SLOT(handleAxisCategoriesUpdated()));
+                QGraphicsSimpleTextItem item;
+                m_font = item.font();
                 handleAxisUpdated();
             }
             ChartAxis::~ChartAxis()
             {
             }
             void ChartAxis::setAnimation(AxisAnimation* animation)
             {
                 m_animation=animation;
             }
             void ChartAxis::setLayout(QVector<qreal> &layout)
             {
                 m_layoutVector=layout;
             }
             void ChartAxis::createItems(int count)
             {
                 if (m_axis->children().size() == 0)
                 m_axis->addToGroup(new AxisItem(this));
                 for (int i = 0; i < count; ++i) {
                     m_grid->addToGroup(new QGraphicsLineItem());
                     m_labels->addToGroup(new QGraphicsSimpleTextItem());
                     m_axis->addToGroup(new QGraphicsLineItem());
                     if ((m_grid->childItems().size())%2 && m_grid->childItems().size()>2) m_shades->addToGroup(new QGraphicsRectItem());
                 }
             }
             void ChartAxis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_axis->childItems();
                 for (int i = 0; i < count; ++i) {
                     if (lines.size()%2 && lines.size() > 1) delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void ChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 int diff = m_layoutVector.size() - layout.size();
                 if (diff>0) {
                     deleteItems(diff);
                 }
                 else if (diff<0) {
                     createItems(-diff);
                 }
                 if( diff!=0) handleAxisUpdated();
                 if (m_animation) {
                       switch(presenter()->state()){
                           case ChartPresenter::ZoomInState:
                               m_animation->setAnimationType(AxisAnimation::ZoomInAnimation);
                               m_animation->setAnimationPoint(presenter()->statePoint());
                               break;
                           case ChartPresenter::ZoomOutState:
                               m_animation->setAnimationType(AxisAnimation::ZoomOutAnimation);
                               m_animation->setAnimationPoint(presenter()->statePoint());
                               break;
                           case ChartPresenter::ScrollUpState:
                           case ChartPresenter::ScrollLeftState:
                               m_animation->setAnimationType(AxisAnimation::MoveBackwordAnimation);
                               break;
                           case ChartPresenter::ScrollDownState:
                           case ChartPresenter::ScrollRightState:
                               m_animation->setAnimationType(AxisAnimation::MoveForwardAnimation);
                               break;
                           case ChartPresenter::ShowState:
                               m_animation->setAnimationType(AxisAnimation::DefaultAnimation);
                               break;
                       }
                       m_animation->setValues(m_layoutVector,layout);
                       presenter()->startAnimation(m_animation);
                 }
                 else {
                     setLayout(layout);
                     updateGeometry();
                 }
             }
             bool ChartAxis::createLabels(QStringList &labels,qreal min, qreal max,int ticks) const
             {
                 Q_ASSERT(max>min);
                 Q_ASSERT(ticks>1);
                 QAxisCategories* categories = m_chartAxis->categories();
                 bool category = categories->count()>0;
                 if (!category) {
                     int n = qMax(int(-floor(log10((max-min)/(ticks-1)))),0);
                     n++;
                     for (int i=0; i< ticks; i++) {
                         qreal value = min + (i * (max - min)/ (ticks-1));
                         Q_UNUSED(value);
                         labels << QString::number(value,'f',n);
                     }
                 } else {
                     QList<qreal> values = categories->values();
                     for (int i=0; i< ticks; i++) {
                         qreal value = (min + (i * (max - min)/ (ticks-1)));
                         int j=0;
                         for (; j<values.count(); j++) {
                             if (values.at(j) > value) break;
                         }
                         if (j!=0) value=values.at(j-1);
                         QString label = categories->label(value);
                         labels << label;
                     }
                 }
                 return category;
             }
             void ChartAxis::setAxisOpacity(qreal opacity)
             {
                 m_axis->setOpacity(opacity);
             }
             qreal ChartAxis::axisOpacity() const
             {
                 return m_axis->opacity();
             }
             void ChartAxis::setGridOpacity(qreal opacity)
             {
                 m_grid->setOpacity(opacity);
             }
             qreal ChartAxis::gridOpacity() const
             {
                 return m_grid->opacity();
             }
             void ChartAxis::setLabelsOpacity(qreal opacity)
             {
                 m_labels->setOpacity(opacity);
             }
             qreal ChartAxis::labelsOpacity() const
             {
                 return m_labels->opacity();
             }
             void ChartAxis::setShadesOpacity(qreal opacity)
             {
                 m_shades->setOpacity(opacity);
             }
             qreal ChartAxis::shadesOpacity() const
             {
                 return m_shades->opacity();
             }
             void ChartAxis::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
             void ChartAxis::setLabelsPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setLabelsBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
             void ChartAxis::setLabelsFont(const QFont &font)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
+                m_font = font;
             }
             void ChartAxis::setShadesBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
             void ChartAxis::setShadesPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setAxisPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_axis->childItems()) {
                        static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setGridPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_grid->childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             bool ChartAxis::isEmpty()
             {
                 return m_rect.isEmpty() || qFuzzyIsNull(m_min - m_max) || m_ticksCount==0;
             }
             //handlers
             void ChartAxis::handleAxisCategoriesUpdated()
             {
                 if (isEmpty()) return;
             	updateLayout(m_layoutVector);
             }
             void ChartAxis::handleAxisUpdated()
             {
                 if (isEmpty()) return;
                 if (m_chartAxis->isAxisVisible()) {
                     setAxisOpacity(100);
                 } else {
                     setAxisOpacity(0);
                 }
                 if (m_chartAxis->isGridLineVisible()) {
                     setGridOpacity(100);
                 } else {
                     setGridOpacity(0);
                 }
                 if (m_chartAxis->labelsVisible()) {
                     setLabelsOpacity(100);
                 } else {
                     setLabelsOpacity(0);
                 }
                 if (m_chartAxis->shadesVisible()) {
                     setShadesOpacity(100);
                 } else {
                     setShadesOpacity(0);
                 }
                 setLabelsAngle(m_chartAxis->labelsAngle());
                 setAxisPen(m_chartAxis->axisPen());
                 setLabelsPen(m_chartAxis->labelsPen());
                 setLabelsBrush(m_chartAxis->labelsBrush());
                 setLabelsFont(m_chartAxis->labelsFont());
                 setGridPen(m_chartAxis->gridLinePen());
                 setShadesPen(m_chartAxis->shadesPen());
                 setShadesBrush(m_chartAxis->shadesBrush());
             }
             void ChartAxis::handleRangeChanged(qreal min, qreal max,int tickCount)
             {
                 if (qFuzzyIsNull(min - max) || tickCount < 2)
                     return;
                 m_min = min;
                 m_max = max;
                 m_ticksCount= tickCount;
                 if (isEmpty()) return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             void ChartAxis::handleGeometryChanged(const QRectF &rect)
             {
                 if(m_rect != rect)
                 {
                     m_rect = rect;
                     if (isEmpty()) return;
                     QVector<qreal> layout = calculateLayout();
                     updateLayout(layout);
                 }
             }
+            qreal ChartAxis::minimumWidth()
+            {
+                if(m_minWidth == 0) updateGeometry();
+                return m_minWidth;
+            }
+            qreal ChartAxis::minimumHeight()
+            {
+                if(m_minHeight == 0) updateGeometry();
+                return m_minHeight;
+            }
             void ChartAxis::axisSelected()
             {
                 qDebug()<<"TODO: axis clicked";
             }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxis_p.h +7 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTAXIS_H
             #define CHARTAXIS_H
             #include "qchartglobal.h"
             #include "chart_p.h"
             #include "axisanimation_p.h"
             #include <QGraphicsItem>
+            #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAxis;
             class ChartPresenter;
             class ChartAxis : public Chart
             {
                 Q_OBJECT
             public:
                 enum AxisType{ X_AXIS,Y_AXIS };
                 ChartAxis(QAxis *axis, ChartPresenter *presenter);
                 ~ChartAxis();
                 virtual AxisType axisType() const = 0;
                 void setAxisOpacity(qreal opacity);
                 qreal axisOpacity() const;
                 void setGridOpacity(qreal opacity);
                 qreal gridOpacity() const;
                 void setLabelsOpacity(qreal opacity);
                 qreal labelsOpacity() const;
                 void setShadesOpacity(qreal opacity);
                 qreal shadesOpacity() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle()const { return m_labelsAngle; }
                 void setShadesBrush(const QBrush &brush);
                 void setShadesPen(const QPen &pen);
                 void setAxisPen(const QPen &pen);
                 void setGridPen(const QPen &pen);
                 void setLabelsPen(const QPen &pen);
                 void setLabelsBrush(const QBrush &brush);
                 void setLabelsFont(const QFont &font);
                 void setLayout(QVector<qreal> &layout);
                 QVector<qreal> layout() const { return m_layoutVector; }
                 void setAnimation(AxisAnimation* animation);
                 ChartAnimation* animation() const { return m_animation; };
                 QRectF geometry() const { return m_rect; }
+                qreal minimumWidth();
+                qreal minimumHeight();
             protected:
                 virtual void updateGeometry() = 0;
                 virtual QVector<qreal> calculateLayout() const = 0;
                 bool createLabels(QStringList &labels,qreal min, qreal max,int ticks) const;
             public Q_SLOTS:
                 void handleAxisUpdated();
                 void handleAxisCategoriesUpdated();
                 void handleRangeChanged(qreal min , qreal max,int tickCount);
                 void handleGeometryChanged(const QRectF &size);
             private:
                 inline bool isEmpty();
                 void createItems(int count);
                 void deleteItems(int count);
                 void updateLayout(QVector<qreal> &layout);
                 void axisSelected();
             protected:
                 QAxis* m_chartAxis;
                 QRectF m_rect;
                 int m_labelsAngle;
                 QScopedPointer<QGraphicsItemGroup> m_grid;
                 QScopedPointer<QGraphicsItemGroup> m_shades;
                 QScopedPointer<QGraphicsItemGroup> m_labels;
                 QScopedPointer<QGraphicsItemGroup> m_axis;
                 QVector<qreal> m_layoutVector;
                 qreal m_min;
                 qreal m_max;
                 int m_ticksCount;
                 AxisAnimation *m_animation;
+                qreal m_minWidth;
+                qreal m_minHeight;
+                QFont m_font;
                 friend class AxisAnimation;
                 friend class AxisItem;
             };
             class AxisItem: public QGraphicsLineItem
             {
             public:
                 explicit AxisItem(ChartAxis *axis, QGraphicsItem *parent = 0) : QGraphicsLineItem(parent), m_axis(axis) {}
             protected:
                void mousePressEvent(QGraphicsSceneMouseEvent *event)
                {
                    Q_UNUSED(event)
                    m_axis->axisSelected();
                }
                QRectF boundingRect() const
                {
                   return shape().boundingRect();
                }
                QPainterPath shape() const
                {
                    QPainterPath path = QGraphicsLineItem::shape();
                    QRectF rect = path.boundingRect();
                    path.addRect(rect.adjusted(0,0,m_axis->axisType()!=ChartAxis::X_AXIS?8:0,m_axis->axisType()!=ChartAxis::Y_AXIS?8:0));
                    return path;
                }
             private:
                ChartAxis* m_axis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/axis/chartaxisx.cpp +22 -10

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartaxisx_p.h"
             #include "qaxis.h"
             #include "qaxis_p.h"
             #include "qaxiscategories_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
+            #include <QGraphicsLayout>
+            #include <QDebug>
+            #include <QFontMetrics>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxisX::ChartAxisX(QAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
             {
             }
             ChartAxisX::~ChartAxisX()
             {
             }
             QVector<qreal> ChartAxisX::calculateLayout() const
             {
                 Q_ASSERT(m_ticksCount>=2);
                 QVector<qreal> points;
                 points.resize(m_ticksCount);
                 const qreal deltaX = m_rect.width()/(m_ticksCount-1);
                 for (int i = 0; i < m_ticksCount; ++i) {
                     int x = i * deltaX + m_rect.left();
                     points[i] = x;
                 }
                 return points;
             }
             void ChartAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
+                m_minWidth = 0;
+                m_minHeight = 0;
+                if(layout.isEmpty()) return;
                 QStringList ticksList;
                 bool categories = createLabels(ticksList,m_min,m_max,layout.size());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_axis->childItems();
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
-                qreal minWidth = 0;
-                qreal minHeight = 0;
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
+                qreal width = 0;
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                     if (!categories || i<1) {
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
-                        minWidth+=rect.width();
-                        minHeight=qMax(rect.height(),minHeight);
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
+                        if(labelItem->pos().x()<=width){
+                            labelItem->setVisible(false);
+                            lineItem->setVisible(false);
+                        }else{
+                            labelItem->setVisible(true);
+                            lineItem->setVisible(true);
+                            width=rect.width()+labelItem->pos().x();
+                        }
+                        m_minWidth+=rect.width();
+                        m_minHeight=qMax(rect.height(),m_minHeight);
                     }
                     else {
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
-                        minWidth+=rect.width();
-                        minHeight=qMax(rect.height()+label_padding,minHeight);
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setPos(layout[i] - (layout[i] - layout[i-1])/2 - center.x(), m_rect.bottom() + label_padding);
+                        m_minWidth+=rect.width();
+                        m_minHeight=qMax(rect.height()+label_padding,m_minHeight);
                     }
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
                         rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
                 }
-                presenter()->setMinimumMarginWidth(this,minWidth);
-                presenter()->setMinimumMarginHeight(this,minHeight);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxisy.cpp +25 -11

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartaxisy_p.h"
             #include "qaxis.h"
             #include "qaxis_p.h"
             #include "qaxiscategories_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
+            #include <QGraphicsLayout>
+            #include <QFontMetrics>
+            #include <QDebug>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxisY::ChartAxisY(QAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
             {
             }
             ChartAxisY::~ChartAxisY()
             {
             }
             QVector<qreal> ChartAxisY::calculateLayout() const
             {
                 Q_ASSERT(m_ticksCount>=2);
                 QVector<qreal> points;
                 points.resize(m_ticksCount);
                 const qreal deltaY = m_rect.height()/(m_ticksCount-1);
                 for (int i = 0; i < m_ticksCount; ++i) {
                     int y = i * -deltaY + m_rect.bottom();
                     points[i] = y;
                 }
                 return points;
             }
             void ChartAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
+                m_minWidth = 0;
+                m_minHeight = 0;
+                if(layout.isEmpty()) return;
                 QStringList ticksList;
                 bool categories = createLabels(ticksList,m_min,m_max,layout.size());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_axis->childItems();
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
-                qreal minWidth = 0;
+                qreal height =  2*m_rect.bottom();
-                qreal minHeight = 0;
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                     if (!categories || i<1) {
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
-                        minWidth=qMax(rect.width()+label_padding,minWidth);
-                        minHeight+=rect.height();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
+                        if(labelItem->pos().y()+rect.height()>height) {
+                            labelItem->setVisible(false);
+                            lineItem->setVisible(false);
+                        }
+                        else {
+                            labelItem->setVisible(true);
+                            lineItem->setVisible(true);
+                            height=labelItem->pos().y();
+                        }
+                        m_minWidth=qMax(rect.width()+label_padding,m_minWidth);
+                        m_minHeight+=rect.height();
                     }
                     else {
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
-                        minWidth=qMax(rect.width(),minWidth);
+                        m_minWidth=qMax(rect.width(),m_minWidth);
-                        minHeight+=rect.height();
+                        m_minHeight+=rect.height();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i] - (layout[i] - layout[i-1])/2 -center.y());
                     }
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
                         rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
                 }
-                presenter()->setMinimumMarginWidth(this,minWidth);
-                presenter()->setMinimumMarginHeight(this,minHeight);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxisy_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTAXISY_H
             #define CHARTAXISY_H
             #include "chartaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAxis;
             class ChartPresenter;
             class ChartAxisY : public ChartAxis
             {
             public:
                 ChartAxisY(QAxis *axis, ChartPresenter *presenter);
                 ~ChartAxisY();
                 AxisType axisType() const { return Y_AXIS;}
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/chartpresenter.cpp +149 -164

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "chartpresenter_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "qaxis.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "chartanimation_p.h"
             #include "qabstractseries_p.h"
             #include "qareaseries.h"
             #include "chartaxis_p.h"
             #include "chartaxisx_p.h"
             #include "chartaxisy_p.h"
             #include "areachartitem_p.h"
             #include "chartbackground_p.h"
+            #include "chartlayout_p.h"
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_animator(0),
             m_dataset(dataset),
             m_chartTheme(0),
-            m_chartRect(QRectF(QPoint(0,0),m_chart->size())),
             m_options(QChart::NoAnimation),
-            m_minLeftMargin(0),
-            m_minBottomMargin(0),
             m_state(ShowState),
+            m_layout(new ChartLayout(this)),
             m_backgroundItem(0),
-            m_titleItem(0),
+            m_titleItem(0)
-            m_marginBig(60),
-            m_marginSmall(20),
-            m_marginTiny(10),
-            m_chartMargins(QRect(m_marginBig,m_marginBig,0,0))
             {
             }
             ChartPresenter::~ChartPresenter()
             {
                 delete m_chartTheme;
             }
             void ChartPresenter::setGeometry(const QRectF& rect)
             {
-                m_rect = rect;
-                Q_ASSERT(m_rect.isValid());
-                updateLayout();
-            void ChartPresenter::setMinimumMarginWidth(ChartAxis* axis, qreal width)
-                switch(axis->axisType()){
-                case ChartAxis::X_AXIS:
-                    if(width>m_chartRect.width()+ m_chartMargins.left()) {
-                        m_minLeftMargin= width - m_chartRect.width();
-                        updateLayout();
-                    break;
-                case ChartAxis::Y_AXIS:
-                    if(m_minLeftMargin!=width){
+                Q_ASSERT(rect.isValid());
-                        m_minLeftMargin= width;
-                        updateLayout();
-                    break;
-            void ChartPresenter::setMinimumMarginHeight(ChartAxis* axis, qreal height)
-                switch(axis->axisType()){
-                case ChartAxis::X_AXIS:
-                    if(m_minBottomMargin!=height) {
-                        m_minBottomMargin= height;
-                        updateLayout();
-                    break;
-                case ChartAxis::Y_AXIS:
-                    if(height>m_chartMargins.bottom()+m_chartRect.height()){
-                        m_minBottomMargin= height - m_chartRect.height();
-                        updateLayout();
-                    break;
+                if(m_rect!=rect) {
+                       m_rect=rect;
+                       emit geometryChanged(m_rect);
                 }
             }
             void ChartPresenter::handleAxisAdded(QAxis* axis,Domain* domain)
             {
                 ChartAxis* item;
                 if(axis == m_dataset->axisX()){
                     item = new ChartAxisX(axis,this);
                 }else{
                     item = new ChartAxisY(axis,this);
                 }
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     item->setAnimator(m_animator);
                     item->setAnimation(new AxisAnimation(item));
                 }
                 if(axis==m_dataset->axisX()){
                     m_chartTheme->decorate(axis,true);
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX(),domain->tickXCount());
                 }
                 else{
                     m_chartTheme->decorate(axis,false);
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY(),domain->tickYCount());
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
                 //initialize
-                if(m_chartRect.isValid()) item->handleGeometryChanged(m_chartRect);
+                if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                 m_axisItems.insert(axis, item);
             }
             void ChartPresenter::handleAxisRemoved(QAxis* axis)
             {
                 ChartAxis* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QAbstractSeries* series,Domain* domain)
             {
                 Chart *item = series->d_ptr->createGraphics(this);
                 Q_ASSERT(item);
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
                 QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                 //initialize
                 item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
-                if(m_chartRect.isValid()) item->handleGeometryChanged(m_chartRect);
+                if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                 m_chartItems.insert(series,item);
             }
             void ChartPresenter::handleSeriesRemoved(QAbstractSeries* series)
             {
                 Chart* item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 if(m_animator) {
                     //small hack to handle area animations
                     if(series->type() == QAbstractSeries::SeriesTypeArea){
                         QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                         AreaChartItem* area = static_cast<AreaChartItem*>(item);
                         m_animator->removeAnimation(area->upperLineItem());
                         if(areaSeries->lowerSeries())  m_animator->removeAnimation(area->lowerLineItem());
                     }else
                         m_animator->removeAnimation(item);
                 }
                 delete item;
             }
             void ChartPresenter::setTheme(QChart::ChartTheme theme,bool force)
             {
                 if(m_chartTheme && m_chartTheme->id() == theme) return;
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->setForced(force);
                 m_chartTheme->decorate(m_chart);
                 m_chartTheme->decorate(m_chart->legend());
                 resetAllElements();
                 // We do not want "force" to stay on.
                 // Bar/pie are calling decorate when adding/removing slices/bars which means
                 // that to preserve users colors "force" must not be on.
                 m_chartTheme->setForced(false);
             }
             QChart::ChartTheme ChartPresenter::theme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     if(m_options!=QChart::NoAnimation && !m_animator) {
                         m_animator= new ChartAnimator(this);
                     }
                     resetAllElements();
                 }
             }
             void ChartPresenter::resetAllElements()
             {
                 QList<QAxis *> axisList = m_axisItems.uniqueKeys();
                 QList<QAbstractSeries *> seriesList = m_chartItems.uniqueKeys();
                 foreach(QAxis *axis, axisList) {
                     handleAxisRemoved(axis);
                     handleAxisAdded(axis,m_dataset->domain(axis));
                 }
                 foreach(QAbstractSeries *series, seriesList) {
                     handleSeriesRemoved(series);
                     handleSeriesAdded(series,m_dataset->domain(series));
             //        m_dataset->removeSeries(series);
             //        m_dataset->addSeries(series);
                 }
             }
             void ChartPresenter::zoomIn(qreal factor)
             {
-                QRectF rect = chartGeometry();
+                QRectF rect = geometry();
                 rect.setWidth(rect.width()/factor);
                 rect.setHeight(rect.height()/factor);
-                rect.moveCenter(chartGeometry().center());
+                rect.moveCenter(geometry().center());
                 zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
                 QRectF r = rect.normalized();
-                r.translate(-m_chartMargins.topLeft());
+                r.translate(-geometry().topLeft());
                 if (!r.isValid())
                     return;
                 m_state = ZoomInState;
-                m_statePoint = QPointF(r.center().x()/chartGeometry().width(),r.center().y()/chartGeometry().height());
+                m_statePoint = QPointF(r.center().x()/geometry().width(),r.center().y()/geometry().height());
-                m_dataset->zoomInDomain(r,chartGeometry().size());
+                m_dataset->zoomInDomain(r,geometry().size());
                 m_state = ShowState;
             }
             void ChartPresenter::zoomOut(qreal factor)
             {
                 m_state = ZoomOutState;
                 QRectF chartRect;
-                chartRect.setSize(chartGeometry().size());
+                chartRect.setSize(geometry().size());
                 QRectF rect;
                 rect.setSize(chartRect.size()/factor);
                 rect.moveCenter(chartRect.center());
                 if (!rect.isValid())
                     return;
-                m_statePoint = QPointF(rect.center().x()/chartGeometry().width(),rect.center().y()/chartGeometry().height());
+                m_statePoint = QPointF(rect.center().x()/geometry().width(),rect.center().y()/geometry().height());
                 m_dataset->zoomOutDomain(rect, chartRect.size());
                 m_state = ShowState;
             }
             void ChartPresenter::scroll(qreal dx,qreal dy)
             {
                 if(dx<0) m_state=ScrollLeftState;
                 if(dx>0) m_state=ScrollRightState;
                 if(dy<0) m_state=ScrollUpState;
                 if(dy>0) m_state=ScrollDownState;
-                m_dataset->scrollDomain(dx,dy,chartGeometry().size());
+                m_dataset->scrollDomain(dx,dy,geometry().size());
                 m_state = ShowState;
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
-            void ChartPresenter::updateLayout()
+            void ChartPresenter::createBackgroundItem()
             {
-                if (!m_rect.isValid()) return;
+                if (!m_backgroundItem) {
+                    m_backgroundItem = new ChartBackground(rootItem());
+                    m_backgroundItem->setPen(Qt::NoPen);
+                    m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
+                }
+            }
-                QRectF oldChargMargins = m_chartMargins;
+            void ChartPresenter::createTitleItem()
+            {
+                if (!m_titleItem) {
+                    m_titleItem = new QGraphicsSimpleTextItem(rootItem());
+                    m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
+                }
+            }
-                // recalculate title size
-                QSize titleSize;
+            void ChartPresenter::handleAnimationFinished()
-                int titlePadding=0;
+               m_animations.removeAll(qobject_cast<ChartAnimation*>(sender()));
+               if(m_animations.empty()) emit animationsFinished();
+            }
-                if (m_titleItem) {
+            void ChartPresenter::startAnimation(ChartAnimation* animation)
-                    titleSize= m_titleItem->boundingRect().size().toSize();
+                if (animation->state() != QAbstractAnimation::Stopped) animation->stop();
+                QObject::connect(animation, SIGNAL(finished()),this,SLOT(handleAnimationFinished()),Qt::UniqueConnection);
+                if(!m_animations.isEmpty()){
+                    m_animations.append(animation);
                 }
+                QTimer::singleShot(0, animation, SLOT(start()));
+            }
-                //defaults
+            QGraphicsRectItem* ChartPresenter::backgroundItem()
-                m_chartMargins = QRect(QPoint(m_minLeftMargin>m_marginBig?m_minLeftMargin:m_marginBig,m_marginBig),QPoint(m_marginBig,m_minBottomMargin>m_marginBig?m_minBottomMargin:m_marginBig));
-                titlePadding = m_chartMargins.top()/2;
+                return m_backgroundItem;
+            }
-                QLegend* legend = m_chart->d_ptr->m_legend;
+            void ChartPresenter::setBackgroundBrush(const QBrush& brush)
+            {
+                createBackgroundItem();
+                m_backgroundItem->setBrush(brush);
+                m_layout->invalidate();
+            }
-                // recalculate legend position
+            QBrush ChartPresenter::backgroundBrush() const
-                if (legend != 0 && legend->isAttachedToChart() && legend->isEnabled()) {
+                if (!m_backgroundItem) return QBrush();
+                return m_backgroundItem->brush();
+            }
-                    // Reserve some space for legend
+            void ChartPresenter::setBackgroundPen(const QPen& pen)
-                    switch (legend->alignment()) {
+                createBackgroundItem();
+                m_backgroundItem->setPen(pen);
+                m_layout->invalidate();
+            }
-                    case Qt::AlignTop: {
+            QPen ChartPresenter::backgroundPen() const
-                        int ledgendSize = legend->minHeight();
-                        int topPadding = 2*m_marginTiny + titleSize.height() + ledgendSize + m_marginTiny;
+                if (!m_backgroundItem) return QPen();
-                        m_chartMargins = QRect(QPoint(m_chartMargins.left(),topPadding),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
+                return m_backgroundItem->pen();
-                        m_legendMargins = QRect(QPoint(m_chartMargins.left(),topPadding - (ledgendSize + m_marginTiny)),QPoint(m_chartMargins.right(),m_rect.height()-topPadding + m_marginTiny));
-                        titlePadding = m_marginTiny + m_marginTiny;
-                        break;
-                    case Qt::AlignBottom: {
-                        int ledgendSize = legend->minHeight();
-                        int bottomPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny + m_minBottomMargin;
-                        m_chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(m_chartMargins.right(),bottomPadding));
-                        m_legendMargins = QRect(QPoint(m_chartMargins.left(),m_rect.height()-bottomPadding + m_marginTiny + m_minBottomMargin),QPoint(m_chartMargins.right(),m_marginTiny + m_marginSmall));
-                        titlePadding = m_chartMargins.top()/2;
-                        break;
-                    case Qt::AlignLeft: {
-                        int ledgendSize = legend->minWidth();
-                        int leftPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny + m_minLeftMargin;
-                        m_chartMargins = QRect(QPoint(leftPadding,m_chartMargins.top()),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
-                        m_legendMargins = QRect(QPoint(m_marginTiny + m_marginSmall,m_chartMargins.top()),QPoint(m_rect.width()-leftPadding + m_marginTiny + m_minLeftMargin,m_chartMargins.bottom()));
-                        titlePadding = m_chartMargins.top()/2;
-                        break;
-                    case Qt::AlignRight: {
-                        int ledgendSize = legend->minWidth();
-                        int rightPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny;
-                        m_chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(rightPadding,m_chartMargins.bottom()));
-                        m_legendMargins = QRect(QPoint(m_rect.width()- rightPadding+ m_marginTiny ,m_chartMargins.top()),QPoint(m_marginTiny + m_marginSmall,m_chartMargins.bottom()));
-                        titlePadding = m_chartMargins.top()/2;
-                        break;
-                    default: {
-                        break;
-                if(m_rect.width()<2*(m_chartMargins.top()+m_chartMargins.bottom()) || m_rect.height()< 2*(m_chartMargins.top() + m_chartMargins.bottom()))
+            QGraphicsItem* ChartPresenter::titleItem()
+            {
-                    m_chart->setMinimumSize(2*(m_chartMargins.top()+m_chartMargins.bottom()),2*(m_chartMargins.top() + m_chartMargins.bottom()));
+                return m_titleItem;
-                    return;
+            void ChartPresenter::setTitle(const QString& title)
+            {
+                createTitleItem();
+                m_titleItem->setText(title);
+                m_layout->invalidate();
+            }
-                // recalculate title position
+            QString ChartPresenter::title() const
-                if (m_titleItem) {
-                    QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
+                if (!m_titleItem) return QString();
-                    m_titleItem->setPos(center.x(),titlePadding);
+                return m_titleItem->text();
+            }
-                //recalculate background gradient
+            void ChartPresenter::setTitleFont(const QFont& font)
-                if (m_backgroundItem) {
-                    m_backgroundItem->setRect(m_rect.adjusted(m_marginTiny,m_marginTiny, -m_marginTiny, -m_marginTiny));
+                createTitleItem();
+                m_titleItem->setFont(font);
+                m_layout->invalidate();
+            }
+            QFont ChartPresenter::titleFont() const
+            {
+                if (!m_titleItem)  return QFont();
+                return m_titleItem->font();
+            }
-                QRectF chartRect = m_rect.adjusted(m_chartMargins.left(),m_chartMargins.top(),-m_chartMargins.right(),-m_chartMargins.bottom());
+            void ChartPresenter::setTitleBrush(const QBrush &brush)
+            {
+                createTitleItem();
+                m_titleItem->setBrush(brush);
+                m_layout->invalidate();
+            }
-                if (legend != 0 && legend->isAttachedToChart() && legend->isEnabled()) {
+            QBrush ChartPresenter::titleBrush() const
-                    legend->setGeometry(m_rect.adjusted(m_legendMargins.left(),m_legendMargins.top(),-m_legendMargins.right(),-m_legendMargins.bottom()));
+                if (!m_titleItem) return QBrush();
+                return m_titleItem->brush();
+            }
+            void ChartPresenter::setBackgroundVisible(bool visible)
+            {
+                createBackgroundItem();
+                m_backgroundItem->setVisible(visible);
+            }
-                if(m_chartRect!=chartRect && chartRect.isValid()){
-                    m_chartRect=chartRect;
-                    emit geometryChanged(m_chartRect);
-                if (oldChargMargins != m_chartMargins)
+            bool ChartPresenter::isBackgroundVisible() const
-                    emit marginsChanged(m_chartMargins);
+                if (!m_backgroundItem) return false;
+                return m_backgroundItem->isVisible();
             }
-            void ChartPresenter::createChartBackgroundItem()
+            void ChartPresenter::setBackgroundDropShadowEnabled(bool enabled)
             {
-                if (!m_backgroundItem) {
+                createBackgroundItem();
-                    m_backgroundItem = new ChartBackground(rootItem());
+                m_backgroundItem->setDropShadowEnabled(enabled);
-                    m_backgroundItem->setPen(Qt::NoPen);
-                    m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
             }
-            void ChartPresenter::createChartTitleItem()
+            bool ChartPresenter::isBackgroundDropShadowEnabled() const
             {
-                if (!m_titleItem) {
+                if (!m_backgroundItem) return false;
-                    m_titleItem = new QGraphicsSimpleTextItem(rootItem());
+                return m_backgroundItem->isDropShadowEnabled();
-                    m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
             }
-            void ChartPresenter::handleAnimationFinished()
+            QGraphicsLayout* ChartPresenter::layout()
             {
-               m_animations.removeAll(qobject_cast<ChartAnimation*>(sender()));
+                return m_layout;
-               if(m_animations.empty()) emit animationsFinished();
             }
-            void ChartPresenter::startAnimation(ChartAnimation* animation)
+            void ChartPresenter::setMarginsMinimum(const QRectF& margins)
             {
-                if (animation->state() != QAbstractAnimation::Stopped) animation->stop();
+                Q_UNUSED(margins);
-                QObject::connect(animation, SIGNAL(finished()),this,SLOT(handleAnimationFinished()),Qt::UniqueConnection);
+              //  m_layout->setMarginsMinimum(margins);
-                if(!m_animations.isEmpty()){
-                    m_animations.append(animation);
+            QRectF ChartPresenter::margins() const
-                QTimer::singleShot(0, animation, SLOT(start()));
+                return QRectF();//m_layout->margins();
+            }
+            QLegend* ChartPresenter::legend()
+            {
+                return m_chart->legend();
+            }
+            QList<ChartAxis*>  ChartPresenter::axisItems() const
+            {
+                return m_axisItems.values();
+            }
+            void ChartPresenter::setVisible(bool visible)
+            {
+                m_chart->setVisible(visible);
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +40 -21

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTPRESENTER_H
             #define CHARTPRESENTER_H
             #include "qchartglobal.h"
             #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
             #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Chart;
             class QAbstractSeries;
             class ChartDataSet;
             class Domain;
             class ChartAxis;
             class ChartTheme;
             class ChartAnimator;
             class ChartBackground;
             class ChartAnimation;
+            class ChartLayout;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     ShadesZValue,
                     GridZValue,
                     SeriesZValue,
                     LineChartZValue = SeriesZValue,
                     BarSeriesZValue = SeriesZValue,
                     ScatterSeriesZValue = SeriesZValue,
                     PieSeriesZValue = SeriesZValue,
                     AxisZValue,
                     LegendZValue
                 };
                 enum State {
                     ShowState,
                     ScrollUpState,
                     ScrollDownState,
                     ScrollLeftState,
                     ScrollRightState,
                     ZoomInState,
                     ZoomOutState
                 };
                 ChartPresenter(QChart* chart,ChartDataSet *dataset);
                 virtual ~ChartPresenter();
                 ChartAnimator* animator() const { return m_animator; }
                 ChartTheme *chartTheme() const { return m_chartTheme; }
                 ChartDataSet *dataSet() const { return m_dataset; }
                 QGraphicsItem* rootItem() const { return m_chart; }
+                QGraphicsRectItem* backgroundItem();
+                QGraphicsItem* titleItem();
+                QList<ChartAxis*> axisItems() const;
+                QLegend* legend();
+                void setBackgroundBrush(const QBrush& brush);
+                QBrush backgroundBrush() const;
+                void setBackgroundPen(const QPen& pen);
+                QPen backgroundPen() const;
+                void setTitle(const QString& title);
+                QString title() const;
+                void setTitleFont(const QFont& font);
+                QFont titleFont() const;
+                void setTitleBrush(const QBrush &brush);
+                QBrush titleBrush() const;
+                void setBackgroundVisible(bool visible);
+                bool isBackgroundVisible() const;
+                void setBackgroundDropShadowEnabled(bool enabled);
+                bool isBackgroundDropShadowEnabled() const;
+                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 setGeometry(const QRectF& rect);
-                QRectF chartGeometry() const { return m_chartRect; }
+                QRectF geometry() { return m_rect; }
-                void setMinimumMarginHeight(ChartAxis* axis, qreal height);
-                void setMinimumMarginWidth(ChartAxis* axis, qreal width);
-                qreal minimumLeftMargin() const { return m_minLeftMargin; }
-                qreal minimumBottomMargin() const { return m_minBottomMargin; }
                 void startAnimation(ChartAnimation* animation);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
-            public: //TODO: fix me
                 void resetAllElements();
-                void createChartBackgroundItem();
-                void createChartTitleItem();
+                void setMarginsMinimum(const QRectF& margins);
-                QRectF margins() const { return m_chartMargins;}
+                QRectF margins() const;
+                QGraphicsLayout* layout();
+            private:
+                void createBackgroundItem();
+                void createTitleItem();
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries* series,Domain* domain);
                 void handleSeriesRemoved(QAbstractSeries* series);
                 void handleAxisAdded(QAxis* axis,Domain* domain);
                 void handleAxisRemoved(QAxis* axis);
-                void updateLayout();
             private Q_SLOTS:
                 void handleAnimationFinished();
             Q_SIGNALS:
                 void geometryChanged(const QRectF& rect);
                 void animationsFinished();
                 void marginsChanged(QRectF margins);
             private:
                 QChart* m_chart;
                 ChartAnimator* m_animator;
                 ChartDataSet* m_dataset;
                 ChartTheme *m_chartTheme;
                 QMap<QAbstractSeries *, Chart *> m_chartItems;
                 QMap<QAxis *, ChartAxis *> m_axisItems;
                 QRectF m_rect;
-                QRectF m_chartRect;
                 QChart::AnimationOptions m_options;
-                qreal m_minLeftMargin;
-                qreal m_minBottomMargin;
                 State m_state;
                 QPointF m_statePoint;
                 QList<ChartAnimation*> m_animations;
+                ChartLayout* m_layout;
-            public: //TODO: fixme
                 ChartBackground* m_backgroundItem;
                 QGraphicsSimpleTextItem* m_titleItem;
-                int m_marginBig;
-                int m_marginSmall;
-                int m_marginTiny;
-                QRectF m_chartMargins;
-                QRectF m_legendMargins;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

src/legend/legend.pri +4 -2

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/qlegend.cpp \
-                $$PWD/legendmarker.cpp
+                $$PWD/legendmarker.cpp \
+                $$PWD/legendlayout.cpp
             PRIVATE_HEADERS += \
                 $$PWD/legendmarker_p.h \
                 $$PWD/legendscroller_p.h \
-                $$PWD/qlegend_p.h
+                $$PWD/qlegend_p.h  \
+                $$PWD/legendlayout_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qlegend.h

src/legend/legendmarker.cpp +35 -22

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "qlegend.h"
             #include "qbarseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qareaseries.h"
             #include "qareaseries_p.h"
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             #include <QGraphicsSimpleTextItem>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendMarker::LegendMarker(QAbstractSeries *series, QLegend *legend) :
                 QGraphicsObject(legend),
                 m_series(series),
                 m_markerRect(0,0,10.0,10.0),
                 m_boundingRect(0,0,0,0),
                 m_legend(legend),
                 m_textItem(new QGraphicsSimpleTextItem(this)),
-                m_rectItem(new QGraphicsRectItem(this))
+                m_rectItem(new QGraphicsRectItem(this)),
+                m_margin(2),
+                m_space(4)
             {
                 //setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
                 m_rectItem->setRect(m_markerRect);
-                updateLayout();
             }
             void LegendMarker::setPen(const QPen &pen)
             {
                 m_rectItem->setPen(pen);
-                updateLayout();
+                m_textItem->setPen(pen);
             }
             QPen LegendMarker::pen() const
             {
                 return m_rectItem->pen();
             }
             void LegendMarker::setBrush(const QBrush &brush)
             {
                 m_rectItem->setBrush(brush);
             }
             QBrush LegendMarker::brush() const
             {
                 return m_rectItem->brush();
             }
             void LegendMarker::setFont(const QFont &font)
             {
                 m_textItem->setFont(font);
-                updateLayout();
             }
             QFont LegendMarker::font() const
             {
                 return m_textItem->font();
             }
             void LegendMarker::setLabel(const QString label)
             {
                 m_textItem->setText(label);
-                updateLayout();
             }
-            void LegendMarker::setSize(const QSize& size)
+            QString LegendMarker::label() const
             {
-                m_markerRect = QRectF(0,0,size.width(),size.height());
+                return m_textItem->text();
             }
-            QString LegendMarker::label() const
+            QRectF LegendMarker::boundingRect() const
             {
-                return m_textItem->text();
+                return m_boundingRect;
             }
             void LegendMarker::setLabelBrush(const QBrush &brush)
             {
                 m_textItem->setBrush(brush);
-                updateLayout();
             }
             QBrush LegendMarker::labelBrush() const
             {
                 return m_textItem->brush();
             }
+            void LegendMarker::setGeometry(const QRectF& rect)
+            {
+                const QRectF& textRect = m_textItem->boundingRect();
+                m_textItem->setPos(m_markerRect.width() + m_space + m_margin,rect.height()/2 - textRect.height()/2);
+                m_rectItem->setPos(m_margin,rect.height()/2 - m_markerRect.height()/2);
+                prepareGeometryChange();
+                m_boundingRect = rect;
+            }
             void LegendMarker::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 Q_UNUSED(painter)
             }
-            QRectF LegendMarker::boundingRect() const
-                return m_boundingRect;
-            void LegendMarker::updateLayout()
+            QSizeF LegendMarker::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
             {
+                Q_UNUSED(constraint)
-                static const qreal margin = 2;
+                QFontMetrics fn(m_textItem->font());
-                static const qreal space = 4;
+                QSizeF sh;
-                const QRectF& textRect = m_textItem->boundingRect();
+                  switch (which) {
-                prepareGeometryChange();
+                    case Qt::MinimumSize:
-                m_boundingRect = QRectF(0,0,m_markerRect.width() + 2*margin + space + textRect.width(),qMax(m_markerRect.height()+2*margin,textRect.height()+2*margin));
+                        sh = QSizeF(fn.boundingRect("...").width(),fn.height());
-                m_textItem->setPos(m_markerRect.width() + space + margin,m_boundingRect.height()/2 - textRect.height()/2);
+                        break;
-                m_rectItem->setPos(margin,m_boundingRect.height()/2 - m_markerRect.height()/2);
+                    case Qt::PreferredSize:
+                        sh = QSizeF(fn.boundingRect(m_textItem->text()).width() + 2*m_margin + m_space +m_markerRect.width(),qMax(m_markerRect.height()+2*m_margin,fn.height()+2*m_margin));
+                        break;
+                    default:
+                      break;
+                  }
+                  return sh;
             }
             void LegendMarker::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 QGraphicsObject::mousePressEvent(event);
                 qDebug()<<"Not implemented"; //TODO: selected signal removed for now
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             AreaLegendMarker::AreaLegendMarker(QAreaSeries *series,QLegend *legend) : LegendMarker(series,legend),
             m_series(series)
             {
                 //QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
                 QObject::connect(series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 QObject::connect(series, SIGNAL(nameChanged()), this, SLOT(updated()));
                 updated();
             }
             void AreaLegendMarker::updated()
             {
                 setBrush(m_series->brush());
                 setLabel(m_series->name());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             BarLegendMarker::BarLegendMarker(QBarSeries *barseries,QBarSet *barset, QLegend *legend) : LegendMarker(barseries,legend),
             m_barset(barset)
             {
                 //QObject::connect(this, SIGNAL(selected()),barset->d_ptr.data(), SIGNAL(selected()));
                 QObject::connect(barset->d_ptr.data(), SIGNAL(updatedBars()), this, SLOT(updated()));
                 updated();
             }
             void BarLegendMarker::updated()
             {
                 setBrush(m_barset->brush());
                 setLabel(m_barset->label());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             PieLegendMarker::PieLegendMarker(QPieSeries* series,QPieSlice *pieslice, QLegend *legend) : LegendMarker(series,legend),
             m_pieslice(pieslice)
             {
                 QObject::connect(pieslice, SIGNAL(labelChanged()), this, SLOT(updated()));
                 QObject::connect(pieslice, SIGNAL(brushChanged()), this, SLOT(updated()));
                 updated();
             }
             void PieLegendMarker::updated()
             {
                 setBrush(m_pieslice->brush());
                 setLabel(m_pieslice->label());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             XYLegendMarker::XYLegendMarker(QXYSeries *series, QLegend *legend) : LegendMarker(series,legend),
             m_series(series)
             {
                 //QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
                 QObject::connect(series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 QObject::connect(series, SIGNAL(nameChanged()), this, SLOT(updated()));
                 updated();
             }
             void XYLegendMarker::updated()
             {
                 setLabel(m_series->name());
                 if(m_series->type()== QAbstractSeries::SeriesTypeScatter)
                 {
                     setBrush(m_series->brush());
                 }
                 else {
                     setBrush(QBrush(m_series->pen().color()));
                 }
             }
             #include "moc_legendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendmarker_p.h +11 -6

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef LEGENDMARKER_P_H
             #define LEGENDMARKER_P_H
             #include "qchartglobal.h"
             #include <QGraphicsObject>
             #include <QBrush>
             #include <QPen>
             #include <QGraphicsSimpleTextItem>
+            #include <QGraphicsLayoutItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractSeries;
             class QAreaSeries;
             class QXYSeries;
             class QBarSet;
             class QBarSeries;
             class QPieSlice;
             class QLegend;
             class QPieSeries;
-            class LegendMarker : public QGraphicsObject
+            class LegendMarker : public QGraphicsObject, public QGraphicsLayoutItem
             {
                 Q_OBJECT
+                Q_INTERFACES(QGraphicsLayoutItem)
             public:
                 explicit LegendMarker(QAbstractSeries *m_series, QLegend *parent);
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setFont(const QFont &font);
                 QFont font() const;
-                void setSize(const QSize& size);
                 void setLabel(const QString label);
                 QString label() const;
                 void setLabelBrush(const QBrush &brush);
                 QBrush labelBrush() const;
                 QAbstractSeries *series() const { return m_series;}
-                void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
+                void setGeometry(const QRectF& rect);
                 QRectF boundingRect() const;
-                void updateLayout();
+                void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
+                QSizeF sizeHint (Qt::SizeHint which, const QSizeF& constraint) const;
             protected:
                 // From QGraphicsObject
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             public Q_SLOTS:
                 virtual void updated() = 0;
             protected:
                 QAbstractSeries *m_series;
                 QRectF m_markerRect;
                 QRectF m_boundingRect;
                 QLegend* m_legend;
                 QGraphicsSimpleTextItem *m_textItem;
                 QGraphicsRectItem *m_rectItem;
+                qreal m_margin;
+                qreal m_space;
             };
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             class XYLegendMarker : public LegendMarker
             {
             public:
                 XYLegendMarker(QXYSeries *series, QLegend *legend);
             protected:
                 void updated();
             private:
                 QXYSeries *m_series;
             };
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             class AreaLegendMarker : public LegendMarker
             {
             public:
                 AreaLegendMarker(QAreaSeries *series, QLegend *legend);
             protected:
                 void updated();
             private:
                 QAreaSeries *m_series;
             };
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             class BarLegendMarker : public LegendMarker
             {
             public:
                 BarLegendMarker(QBarSeries *barseries, QBarSet *barset,QLegend *legend);
             protected:
                 void updated();
             private:
                 QBarSet *m_barset;
             };
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             class PieLegendMarker : public LegendMarker
             {
             public:
                 PieLegendMarker(QPieSeries *pieSeries, QPieSlice *pieslice, QLegend *legend);
             protected:
                 void updated();
             private:
                 QPieSlice *m_pieslice;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // LEGENDMARKER_P_H

src/legend/qlegend.cpp +55 -375

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "qlegend.h"
             #include "qlegend_p.h"
             #include "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "qchart_p.h"
+            #include "legendlayout_p.h"
             #include "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qbarset.h"
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QTimer>
+            #include <QGraphicsLayout>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegend
                 \brief Legend object
                 \mainclass
                 QLegend is a graphical object, whics displays legend of the chart. Legend state is updated by QChart, when
                 series have been changed. By default, legend is drawn by QChart, but user can set a new parent to legend and
                 handle the drawing manually.
                 User isn't supposed to create or delete legend objects, but can reference it via QChart class.
                 \image examples_percentbarchart_legend.png
                 \sa QChart
             */
             /*!
                 \qmlclass Legend QLegend
                 \brief Legend is part of QtCommercial Chart QML API.
                 Legend is a graphical object, whics displays legend of the chart. Legend state is updated by ChartView, when
                 series have been changed. Legend is used via ChartView class. For example:
                 \code
                     ChartView {
                         legend.visible: true
                         legend.alignment: Qt.AlignBottom
                         // Add a few series...
                     }
                 \endcode
                 \image examples_percentbarchart_legend.png
             */
             /*!
                 \property QLegend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt::AlignTop, Qt::AlignBottom, Qt::AlignLeft, Qt::AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \qmlproperty Qt.Alignment Legend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt.AlignTop, Qt.AlignBottom, Qt.AlignLeft, Qt.AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \property QLegend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \qmlproperty bool Legend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \property QLegend::color
                 The color of the legend, i.e. the background (brush) color. Note that if you change the color
                 of the legend, the style of the legend brush is set to Qt::SolidPattern.
             */
             /*!
                 \qmlproperty color Legend::color
                 The color of the legend, i.e. the background (brush) color.
             */
             /*!
                 \property QLegend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
                 \qmlproperty color Legend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
                 \property QLegend::font
                 The font of markers used by legend
             */
             /*!
                 \qmlproperty color Legend::font
                 The font of markers used by legend
             */
             /*!
                 \property QLegend::labelColor
                 The color of brush used to draw labels.
             */
             /*!
                 \qmlproperty color QLegend::labelColor
                 The color of brush used to draw labels.
             */
             /*!
                 \fn void QLegend::backgroundVisibleChanged(bool)
                 The visibility of the legend background changed to \a visible.
             */
             /*!
                 \fn void QLegend::colorChanged(QColor)
                 The color of the legend background changed to \a color.
             */
             /*!
                 \fn void QLegend::borderColorChanged(QColor)
                 The border color of the legend background changed to \a color.
             */
             /*!
                 \fn void QLegend::fontChanged(QFont)
                 The font of markers of the legend changed to \a font.
             */
             /*!
                 \fn void QLegend::labelBrushChanged(QBrush brush)
                 This signal is emitted when the brush used to draw labels has changed to \a brush.
             */
             /*!
                 \fn void QLegend::labelColorChanged(QColor color)
                 This signal is emitted when the color of brush used to draw labels has changed to \a color.
             */
             /*!
              \fn qreal QLegend::minWidth() const
              Returns minimum width of the legend
              */
             /*!
              \fn qreal QLegend::minHeight() const
              Returns minimum height of the legend
              */
             /*!
              Constructs the legend object and sets the parent to \a parent
              */
             QLegend::QLegend(QChart *chart):QGraphicsWidget(chart),
             d_ptr(new QLegendPrivate(chart->d_ptr->m_presenter,chart,this))
             {
                 setZValue(ChartPresenter::LegendZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesAdded(QAbstractSeries*,Domain*)),d_ptr.data(),SLOT(handleSeriesAdded(QAbstractSeries*,Domain*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesRemoved(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesUpdated(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesUpdated(QAbstractSeries*)));
+                setLayout(d_ptr->m_layout);
             }
             /*!
                 Destroys the legend object. Legend is always owned by a QChart, so an application should never call this.
             */
             QLegend::~QLegend()
             {
             }
             /*!
              \internal
              */
             void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 if(!d_ptr->m_backgroundVisible) return;
                 painter->setOpacity(opacity());
                 painter->setPen(d_ptr->m_pen);
                 painter->setBrush(d_ptr->m_brush);
                 painter->drawRoundRect(rect(),d_ptr->roundness(rect().width()),d_ptr->roundness(rect().height()));
-            /*!
-             \internal
-             */
-            QRectF QLegend::boundingRect() const
-                return d_ptr->m_rect;
             }
             /*!
              Sets the \a brush of legend. Brush affects the background of legend.
              */
             void QLegend::setBrush(const QBrush &brush)
             {
                 if (d_ptr->m_brush != brush) {
                     d_ptr->m_brush = brush;
                     update();
                 }
             }
             /*!
              Returns the brush used by legend.
              */
             QBrush QLegend::brush() const
             {
                 return d_ptr->m_brush;
             }
             void QLegend::setColor(QColor color)
             {
                 QBrush b = d_ptr->m_brush;
                 if (b.style() != Qt::SolidPattern || b.color() != color) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     setBrush(b);
                     emit colorChanged(color);
                 }
             }
             QColor QLegend::color()
             {
                 return d_ptr->m_brush.color();
             }
             /*!
              Sets the \a pen of legend. Pen affects the legend borders.
              */
             void QLegend::setPen(const QPen &pen)
             {
                 if (d_ptr->m_pen != pen) {
                     d_ptr->m_pen = pen;
                     update();
                 }
             }
             /*!
              Returns the pen used by legend
              */
             QPen QLegend::pen() const
             {
                 return d_ptr->m_pen;
             }
+            void QLegend::setFont(const QFont &font)
+            {
+                if (d_ptr->m_font != font) {
+                    d_ptr->m_font = font;
+                    foreach (LegendMarker *marker, d_ptr->markers()) {
+                        marker->setFont(d_ptr->m_font);
+                    }
+                    emit fontChanged(font);
+                }
+            }
+            QFont QLegend::font() const
+            {
+               return d_ptr->m_font;
+            }
             void QLegend::setBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_pen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             QColor QLegend::borderColor()
             {
                 return d_ptr->m_pen.color();
             }
-            void QLegend::setFont(const QFont &font)
-                if (d_ptr->m_font != font) {
-                    d_ptr->setFont(font);
-                    emit fontChanged(font);
-            QFont QLegend::font() const
-                return d_ptr->m_font;
             /*!
                 Set brush used to draw labels to \a brush.
             */
             void QLegend::setLabelBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelBrush != brush) {
-                    d_ptr->setLabelBrush(brush);
+                    d_ptr->m_labelBrush = brush;
+                    foreach (LegendMarker *marker, d_ptr->markers()) {
+                        marker->setLabelBrush(d_ptr->m_labelBrush);
+                    }
                     emit labelBrushChanged(brush);
                 }
             }
             /*!
                 Brush used to draw labels.
             */
             QBrush QLegend::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             void QLegend::setLabelColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelBrush;
                 if (b.style() != Qt::SolidPattern || b.color() != color) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     setLabelBrush(b);
                     emit labelColorChanged(color);
                 }
             }
             QColor QLegend::labelColor() const
             {
                 return d_ptr->m_labelBrush.color();
             }
             void QLegend::setAlignment(Qt::Alignment alignment)
             {
                 if(d_ptr->m_alignment!=alignment) {
                     d_ptr->m_alignment = alignment;
-                    d_ptr->updateLayout();
+                    updateGeometry();
+                    if(isAttachedToChart()){
+                        d_ptr->m_presenter->layout()->invalidate();
+                    }else{
+                        layout()->invalidate();
+                    }
                 }
             }
             Qt::Alignment QLegend::alignment() const
             {
                 return d_ptr->m_alignment;
             }
             /*!
              Detaches the legend from chart. Chart won't change layout of the legend.
              */
             void QLegend::detachFromChart()
             {
                 d_ptr->m_attachedToChart = false;
+                d_ptr->m_layout->invalidate();
+                setParent(0);
             }
             /*!
              Attaches the legend to chart. Chart may change layout of the legend.
              */
             void QLegend::attachToChart()
             {
-                d_ptr->attachToChart();
+                d_ptr->m_attachedToChart = true;
+                d_ptr->m_layout->invalidate();
+                setParent(d_ptr->m_chart);
             }
             /*!
              Returns true, if legend is attached to chart.
              */
             bool QLegend::isAttachedToChart()
             {
                 return d_ptr->m_attachedToChart;
             }
             /*!
              Sets the visibility of legend background to \a visible
              */
             void QLegend::setBackgroundVisible(bool visible)
             {
                 if(d_ptr->m_backgroundVisible != visible) {
                     d_ptr->m_backgroundVisible = visible;
                     update();
                     emit backgroundVisibleChanged(visible);
                 }
             }
             /*!
              Returns the visibility of legend background
              */
             bool QLegend::isBackgroundVisible() const
             {
                 return d_ptr->m_backgroundVisible;
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
-            void QLegend::resizeEvent(QGraphicsSceneResizeEvent *event)
-                const QRectF& rect = QRectF(QPoint(0,0),event->newSize());
-                QGraphicsWidget::resizeEvent(event);
-                if(d_ptr->m_rect != rect) {
-                    d_ptr->m_rect = rect;
-                    d_ptr->updateLayout();
-            /*!
-             \internal \a event see QGraphicsWidget for details
-             */
             void QLegend::hideEvent(QHideEvent *event)
             {
                 QGraphicsWidget::hideEvent(event);
-                setEnabled(false);
+                d_ptr->m_presenter->layout()->invalidate();
-                d_ptr->updateLayout();
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::showEvent(QShowEvent *event)
             {
                 QGraphicsWidget::showEvent(event);
-                setEnabled(true);
+                d_ptr->m_presenter->layout()->invalidate();
-                d_ptr->updateLayout();
-            qreal QLegend::minWidth() const
-                return d_ptr->m_minWidth;
-            qreal QLegend::minHeight() const
-                return d_ptr->m_minHeight;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendPrivate::QLegendPrivate(ChartPresenter* presenter, QChart *chart, QLegend *q):
                 q_ptr(q),
                 m_presenter(presenter),
+                m_layout(new LegendLayout(q)),
                 m_chart(chart),
-                m_markers(new QGraphicsItemGroup(q)),
+                m_items(new QGraphicsItemGroup(q)),
                 m_alignment(Qt::AlignTop),
                 m_brush(QBrush()),
                 m_pen(QPen()),
                 m_labelBrush(QBrush()),
-                m_offsetX(0),
-                m_offsetY(0),
-                m_minWidth(0),
-                m_minHeight(0),
-                m_width(0),
-                m_height(0),
                 m_diameter(5),
                 m_attachedToChart(true),
                 m_backgroundVisible(false)
             {
             }
             QLegendPrivate::~QLegendPrivate()
             {
             }
             void QLegendPrivate::setOffset(qreal x, qreal y)
             {
-                bool scrollHorizontal = true;
+               m_layout->setOffset(x,y);
-                switch(m_alignment) {
-                    case Qt::AlignTop:
-                    case Qt::AlignBottom: {
-                        scrollHorizontal = true;
-                        break;
-                    case Qt::AlignLeft:
-                    case Qt::AlignRight: {
-                        scrollHorizontal = false;
-                        break;
-                // If detached, the scrolling direction is vertical instead of horizontal and vice versa.
-                if (!m_attachedToChart) {
-                    scrollHorizontal = !scrollHorizontal;
-                // Limit offset between m_minOffset and m_maxOffset
-                if (scrollHorizontal) {
-                    if(m_width<=m_rect.width()) return;
-                    if (x != m_offsetX) {
-                        m_offsetX = qBound(m_minOffsetX, x, m_maxOffsetX);
-                        m_markers->setPos(-m_offsetX,m_rect.top());
-                } else {
-                    if(m_height<=m_rect.height()) return;
-                    if (y != m_offsetY) {
-                        m_offsetY = qBound(m_minOffsetY, y, m_maxOffsetY);
-                        m_markers->setPos(m_rect.left(),-m_offsetY);
             }
             QPointF QLegendPrivate::offset() const
             {
-                return QPointF(m_offsetX,m_offsetY);
+                return m_layout->offset();
-            void QLegendPrivate::updateLayout()
-                if (!m_attachedToChart) {
-                    updateDetachedLayout();
-                    return;
-                m_offsetX=0;
-                QList<QGraphicsItem *> items = m_markers->childItems();
-                if(items.isEmpty()) return;
-                m_minWidth=0;
-                m_minHeight=0;
-                switch(m_alignment) {
-                    case Qt::AlignTop:
-                    case Qt::AlignBottom: {
-                        QPointF point = m_rect.topLeft();
-                        m_width = 0;
-                        foreach (QGraphicsItem *item, items) {
-                            if (item->isVisible()) {
-                                item->setPos(point.x(),m_rect.height()/2 -item->boundingRect().height()/2);
-                                const QRectF& rect = item->boundingRect();
-                                qreal w = rect.width();
-                                m_minWidth=qMax(m_minWidth,w);
-                                m_minHeight=qMax(m_minHeight,rect.height());
-                                m_width+=w;
-                                point.setX(point.x() + w);
-                        if(m_width<m_rect.width()) {
-                            m_markers->setPos(m_rect.width()/2-m_width/2,m_rect.top());
-                        else {
-                            m_markers->setPos(m_rect.topLeft());
-                        m_height=m_minHeight;
-                    break;
-                    case Qt::AlignLeft:
-                    case Qt::AlignRight: {
-                        QPointF point = m_rect.topLeft();
-                        m_height = 0;
-                        foreach (QGraphicsItem *item, items) {
-                            if (item->isVisible()) {
-                                item->setPos(point);
-                                const QRectF& rect = item->boundingRect();
-                                qreal h = rect.height();
-                                m_minWidth=qMax(m_minWidth,rect.width());
-                                m_minHeight=qMax(m_minHeight,h);
-                                m_height+=h;
-                                point.setY(point.y() + h);
-                        if(m_height<m_rect.height()) {
-                            m_markers->setPos(m_rect.left(),m_rect.height()/2-m_height/2);
-                        else {
-                            m_markers->setPos(m_rect.topLeft());
-                        m_width=m_minWidth;
-                    break;
-                m_minOffsetX = 0;
-                m_minOffsetY = 0;
-                m_maxOffsetX = m_width - m_rect.width();
-                m_maxOffsetY = m_height - m_rect.height();
-                m_presenter->updateLayout();
-            void QLegendPrivate::updateDetachedLayout()
-                // Detached layout is different.
-                // In detached mode legend may have multiple rows and columns, so layout calculations
-                // differ a log from attached mode.
-                // Also the scrolling logic is bit different.
-                m_offsetX=0;
-                m_offsetY=0;
-                QList<QGraphicsItem *> items = m_markers->childItems();
-                if(items.isEmpty()) return;
-                m_minWidth = 0;
-                m_minHeight = 0;
-                switch (m_alignment) {
-                    case Qt::AlignTop: {
-                        QPointF point = m_rect.topLeft();
-                        m_width = 0;
-                        m_height = 0;
-                        for (int i=0; i<items.count(); i++) {
-                            QGraphicsItem *item = items.at(i);
-                            if (item->isVisible()) {
-                                const QRectF& rect = item->boundingRect();
-                                qreal w = rect.width();
-                                qreal h = rect.height();
-                                m_minWidth = qMax(m_minWidth,w);
-                                m_minHeight = qMax(m_minHeight,rect.height());
-                                m_height = qMax(m_height,h);
-                                item->setPos(point.x(),point.y());
-                                point.setX(point.x() + w);
-                                if (point.x() + w > m_rect.topLeft().x() + m_rect.width()) {
-                                    // Next item would go off rect.
-                                    point.setX(m_rect.topLeft().x());
-                                    point.setY(point.y() + h);
-                                    if (i+1 < items.count()) {
-                                        m_height += h;
-                        m_markers->setPos(m_rect.topLeft());
-                        m_width = m_minWidth;
-                        m_minOffsetX = 0;
-                        m_minOffsetY = 0;
-                        m_maxOffsetX = m_width - m_rect.width();
-                        m_maxOffsetY = m_height - m_rect.height();
-                    break;
-                    case Qt::AlignBottom: {
-                        QPointF point = m_rect.bottomLeft();
-                        m_width = 0;
-                        m_height = 0;
-                        for (int i=0; i<items.count(); i++) {
-                            QGraphicsItem *item = items.at(i);
-                            if (item->isVisible()) {
-                                const QRectF& rect = item->boundingRect();
-                                qreal w = rect.width();
-                                qreal h = rect.height();
-                                m_minWidth = qMax(m_minWidth,w);
-                                m_minHeight = qMax(m_minHeight,rect.height());
-                                m_height = qMax(m_height,h);
-                                item->setPos(point.x(),point.y() - h);
-                                point.setX(point.x() + w);
-                                if (point.x() + w > m_rect.bottomLeft().x() + m_rect.width()) {
-                                    // Next item would go off rect.
-                                    point.setX(m_rect.bottomLeft().x());
-                                    point.setY(point.y() - h);
-                                    if (i+1 < items.count()) {
-                                        m_height += h;
-                        m_markers->setPos(m_rect.topLeft());
-                        m_width = m_minWidth;
-                        m_minOffsetX = 0;
-                        m_minOffsetY = qMin(m_rect.topLeft().y(), m_rect.topLeft().y() - m_height + m_rect.height());
-                        m_maxOffsetX = m_width - m_rect.width();
-                        m_maxOffsetY = 0;
-                    break;
-                    case Qt::AlignLeft: {
-                        QPointF point = m_rect.topLeft();
-                        m_width = 0;
-                        m_height = 0;
-                        qreal maxWidth = 0;
-                        for (int i=0; i<items.count(); i++) {
-                            QGraphicsItem *item = items.at(i);
-                            if (item->isVisible()) {
-                                const QRectF& rect = item->boundingRect();
-                                qreal w = rect.width();
-                                qreal h = rect.height();
-                                m_minWidth = qMax(m_minWidth,rect.width());
-                                m_minHeight = qMax(m_minHeight,h);
-                                maxWidth = qMax(maxWidth,w);
-                                item->setPos(point.x(),point.y());
-                                point.setY(point.y() + h);
-                                if (point.y() + h > m_rect.topLeft().y() + m_rect.height()) {
-                                    // Next item would go off rect.
-                                    point.setX(point.x() + maxWidth);
-                                    point.setY(m_rect.topLeft().y());
-                                    if (i+1 < items.count()) {
-                                        m_width += maxWidth;
-                                        maxWidth = 0;
-                        m_width += maxWidth;
-                        m_markers->setPos(m_rect.topLeft());
-                        m_height = m_minHeight;
-                        m_minOffsetX = 0;
-                        m_minOffsetY = 0;
-                        m_maxOffsetX = m_width - m_rect.width();
-                        m_maxOffsetY = m_height - m_rect.height();
-                    break;
-                    case Qt::AlignRight: {
-                        QPointF point = m_rect.topRight();
-                        m_width = 0;
-                        m_height = 0;
-                        qreal maxWidth = 0;
-                        for (int i=0; i<items.count(); i++) {
-                            QGraphicsItem *item = items.at(i);
-                            if (item->isVisible()) {
-                                const QRectF& rect = item->boundingRect();
-                                qreal w = rect.width();
-                                qreal h = rect.height();
-                                m_minWidth = qMax(m_minWidth,rect.width());
-                                m_minHeight = qMax(m_minHeight,h);
-                                maxWidth = qMax(maxWidth,w);
-                                item->setPos(point.x() - w,point.y());
-                                point.setY(point.y() + h);
-                                if (point.y() + h > m_rect.topLeft().y() + m_rect.height()) {
-                                    // Next item would go off rect.
-                                    point.setX(point.x() - maxWidth);
-                                    point.setY(m_rect.topLeft().y());
-                                    if (i+1 < items.count()) {
-                                        m_width += maxWidth;
-                                        maxWidth = 0;
-                        m_width += maxWidth;
-                        m_markers->setPos(m_rect.topLeft());
-                        m_height = m_minHeight;
-                        m_minOffsetX = qMin(m_rect.topLeft().x(), m_rect.topLeft().x() - m_width + m_rect.width());
-                        m_minOffsetY = 0;
-                        m_maxOffsetX = 0;
-                        m_maxOffsetY = m_height - m_rect.height();
-                    break;
-                    default:
-                    break;
-            void QLegendPrivate::attachToChart()
-                m_attachedToChart = true;
-                q_ptr->setParent(m_chart);
             }
             int QLegendPrivate::roundness(qreal size)
             {
                 return 100*m_diameter/int(size);
             }
-            void QLegendPrivate::setFont(const QFont &font)
-                m_font = font;
-                QList<QGraphicsItem *> items = m_markers->childItems();
-                foreach (QGraphicsItem *markers, items) {
-                    LegendMarker *marker = static_cast<LegendMarker*>(markers);
-                    marker->setFont(m_font);
-                updateLayout();
-            void QLegendPrivate::setLabelBrush(const QBrush &brush)
-                m_labelBrush = brush;
-                QList<QGraphicsItem *> items = m_markers->childItems();
-                foreach (QGraphicsItem *markers, items) {
-                    LegendMarker *marker = static_cast<LegendMarker*>(markers);
-                    marker->setLabelBrush(m_labelBrush);
-                updateLayout();
             void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
                 QList<LegendMarker*> markers = series->d_ptr->createLegendMarker(q_ptr);
                 foreach(LegendMarker* marker, markers) {
                     marker->setFont(m_font);
                     marker->setLabelBrush(m_labelBrush);
-                    m_markers->addToGroup(marker);
+                    m_items->addToGroup(marker);
+                    m_markers<<marker;
                 }
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 if(series->type() == QAbstractSeries::SeriesTypePie) {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::connect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::connect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
-                updateLayout();
+                q_ptr->layout()->invalidate();
             }
             void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series)
             {
-                QList<QGraphicsItem *> items = m_markers->childItems();
+                foreach (LegendMarker *marker, m_markers) {
-                foreach (QGraphicsItem *markers, items) {
-                    LegendMarker *marker = static_cast<LegendMarker*>(markers);
                     if (marker->series() == series) {
                         delete marker;
+                        m_markers.removeAll(marker);
                     }
                 }
                 if(series->type() == QAbstractSeries::SeriesTypePie)
                 {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::disconnect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::disconnect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
-                updateLayout();
+                q_ptr->layout()->invalidate();
             }
             void QLegendPrivate::handleSeriesUpdated(QAbstractSeries *series)
             {
                 // TODO: find out which markers are are added or removed. Update them
                 // TODO: better implementation
                 handleSeriesRemoved(series);
                 Domain domain;
                 handleSeriesAdded(series, &domain);
             }
             void QLegendPrivate::handleUpdatePieSeries()
             {
                 //TODO: reimplement to be optimal
                 QPieSeries* series = qobject_cast<QPieSeries *> (sender());
                 Q_ASSERT(series);
                 handleSeriesRemoved(series);
                 handleSeriesAdded(series, 0);
             }
             void QLegendPrivate::handleSeriesVisibleChanged()
             {
                 QAbstractSeries* series = qobject_cast<QAbstractSeries *> (sender());
-                QList<QGraphicsItem *> items = m_markers->childItems();
-                foreach (QGraphicsItem *markers, items) {
+                foreach (LegendMarker* marker, m_markers) {
-                    LegendMarker *marker = static_cast<LegendMarker*>(markers);
                     if (marker->series() == series) {
                         marker->setVisible(!marker->isVisible());
                     }
                 }
-                updateLayout();
+                q_ptr->layout()->invalidate();
             }
             #include "moc_qlegend.cpp"
             #include "moc_qlegend_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.h +3 -5

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QLEGEND_H
             #define QLEGEND_H
             #include <QChartGlobal>
             #include <QGraphicsWidget>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain;
             class LegendMarker;
             class QPieSlice;
             class QXYSeries;
             class QBarSet;
             class QBarSeries;
             class QPieSeries;
             class QAreaSeries;
             class LegendScrollButton;
             class QChart;
             class QLegendPrivate;
             class QTCOMMERCIALCHART_EXPORT QLegend : public QGraphicsWidget
             {
                 Q_OBJECT
                 Q_PROPERTY(Qt::Alignment alignment READ alignment WRITE setAlignment)
                 Q_PROPERTY(bool backgroundVisible READ isBackgroundVisible WRITE setBackgroundVisible NOTIFY backgroundVisibleChanged)
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
                 Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor NOTIFY borderColorChanged)
                 Q_PROPERTY(QFont font READ font WRITE setFont NOTIFY fontChanged)
                 Q_PROPERTY(QColor labelColor READ labelColor WRITE setLabelColor NOTIFY labelColorChanged)
             private:
                 explicit QLegend(QChart *chart);
             public:
                 ~QLegend();
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
-                QRectF boundingRect() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setColor(QColor color);
                 QColor color();
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBorderColor(QColor color);
                 QColor borderColor();
                 void setFont(const QFont &font);
                 QFont font() const;
                 void setLabelBrush(const QBrush &brush);
                 QBrush labelBrush() const;
                 void setLabelColor(QColor color);
                 QColor labelColor() const;
                 void setAlignment(Qt::Alignment alignment);
                 Qt::Alignment alignment() const;
                 void detachFromChart();
                 void attachToChart();
                 bool isAttachedToChart();
-                qreal minWidth() const;
-                qreal minHeight() const;
                 void setBackgroundVisible(bool visible = true);
                 bool isBackgroundVisible() const;
             protected:
-                void resizeEvent(QGraphicsSceneResizeEvent *event);
                 void hideEvent(QHideEvent *event);
                 void showEvent(QShowEvent *event);
             Q_SIGNALS:
                 void backgroundVisibleChanged(bool visible);
                 void colorChanged(QColor color);
                 void borderColorChanged(QColor color);
                 void fontChanged(QFont font);
                 void labelBrushChanged(QBrush brush);
                 void labelColorChanged(QColor color);
             private:
                 QScopedPointer<QLegendPrivate> d_ptr;
                 Q_DISABLE_COPY(QLegend)
                 friend class LegendScroller;
+                friend class LegendLayout;
+                friend class ChartLayout;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGEND_H

src/legend/qlegend_p.h +8 -17

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QLEGEND_P_H
             #define QLEGEND_P_H
             #include "qlegend.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class ChartPresenter;
             class QAbstractSeries;
+            class LegendLayout;
             class QLegendPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QLegendPrivate(ChartPresenter *presenter, QChart *chart, QLegend *q);
                 ~QLegendPrivate();
                 void setOffset(qreal x, qreal y);
                 QPointF offset() const;
-                void updateLayout();
-                void updateDetachedLayout();
-                void attachToChart();
                 int roundness(qreal size);
-                void setFont(const QFont &font);
-                void setLabelBrush(const QBrush &brush);
+                QList<LegendMarker*> markers() { return m_markers; }
+                QGraphicsItemGroup* items() { return m_items; }
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series, Domain *domain);
                 void handleSeriesRemoved(QAbstractSeries *series);
                 void handleSeriesUpdated(QAbstractSeries *series);
                 void handleUpdatePieSeries(); //TODO remove this function
                 void handleSeriesVisibleChanged();
             private:
                 QLegend *q_ptr;
                 ChartPresenter *m_presenter;
+                LegendLayout *m_layout;
                 QChart* m_chart;
-                QGraphicsItemGroup* m_markers;
+                QGraphicsItemGroup* m_items;
+                QList<LegendMarker*> m_markers;
                 Qt::Alignment m_alignment;
                 QBrush m_brush;
                 QPen m_pen;
                 QFont m_font;
                 QBrush m_labelBrush;
-                QRectF m_rect;
-                qreal m_offsetX;
-                qreal m_offsetY;
-                qreal m_minOffsetX;
-                qreal m_minOffsetY;
-                qreal m_maxOffsetX;
-                qreal m_maxOffsetY;
-                qreal m_minWidth;
-                qreal m_minHeight;
-                qreal m_width;
-                qreal m_height;
                 qreal m_diameter;
                 bool m_attachedToChart;
                 bool m_backgroundVisible;
             friend class QLegend;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchart.cpp +29 -65

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qchart.h"
             #include "qchart_p.h"
             #include "legendscroller_p.h"
             #include "qlegend_p.h"
             #include "chartbackground_p.h"
             #include "qaxis.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
+            #include <QGraphicsLayout>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              \enum QChart::ChartTheme
              This enum describes the theme used by the chart.
              \value ChartThemeLight The default theme
              \value ChartThemeBlueCerulean
              \value ChartThemeDark
              \value ChartThemeBrownSand
              \value ChartThemeBlueNcs
              \value ChartThemeHighContrast
              \value ChartThemeBlueIcy
              */
             /*!
              \enum QChart::AnimationOption
              For enabling/disabling animations. Defaults to NoAnimation.
              \value NoAnimation
              \value GridAxisAnimations
              \value SeriesAnimations
              \value AllAnimations
              */
             /*!
              \class QChart
              \brief QtCommercial chart API.
              QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
              representation of different types of series and other chart related objects like
              QAxis and QLegend. If you simply want to show a chart in a layout, you can use the
              convenience class QChartView instead of QChart.
              \sa QChartView
              */
             /*!
              \property QChart::animationOptions
              The animation \a options for the chart. Animations are enabled/disabled based on this setting.
              */
             /*!
              \property QChart::backgroundVisible
              Whether the chart background is visible or not.
              \sa setBackgroundBrush(), setBackgroundPen()
              */
             /*!
              \property QChart::dropShadowEnabled
              If set to true, the background drop shadow effect is enabled. If set to false, it is disabled. Note that the drop
              shadow effect depends on theme, which means the setting may be changed if you switch to another theme.
              */
             /*!
              \property QChart::margins
              Margins around the plot area. Note that the margin area is used for drawing chart title, legend and axes.
              */
             /*!
              \property QChart::theme
              Theme is a built-in collection of UI style related settings applied for all visual elements of a chart, like colors,
              pens, brushes and fonts of series, axes, title and legend. \l {Chart themes demo} shows an example with a few
              different themes.
              Note: changing the theme will overwrite all customizations previously applied to the series.
              */
             /*!
              \property QChart::title
              Title is the name (label) of a chart. It is shown as a headline on top of the chart.
              */
             /*!
              \fn void QChart::marginsChanged(QRectF newMargins)
              The margins around plot area have changed to \a newMargins. This may happen for example if you change title font size,
              modify axes or hide/show legend.
              */
             /*!
              Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
                 d_ptr(new QChartPrivate())
             {
                 d_ptr->m_dataset = new ChartDataSet(this);
                 d_ptr->m_presenter = new ChartPresenter(this,d_ptr->m_dataset);
                 d_ptr->createConnections();
                 d_ptr->m_legend = new LegendScroller(this);
                 d_ptr->m_presenter->setTheme(QChart::ChartThemeLight, false);
-                connect(d_ptr->m_presenter, SIGNAL(marginsChanged(QRectF)), this, SIGNAL(marginsChanged(QRectF)));
+                //connect(d_ptr->m_presenter, SIGNAL(marginsChanged(QRectF)), this, SIGNAL(marginsChanged(QRectF)));
+                setLayout(d_ptr->m_presenter->layout());
             }
             /*!
              Destroys the object and it's children, like series and axis objects added to it.
              */
             QChart::~QChart()
             {
                 //delete first presenter , since this is a root of all the graphical items
+                setLayout(0);
                 delete d_ptr->m_presenter;
                 d_ptr->m_presenter=0;
             }
             /*!
              Adds the \a series and optional \a axisY onto the chart and takes the ownership of the objects.
              If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
              the y axis).
              \sa removeSeries(), removeAllSeries()
              */
             void QChart::addSeries(QAbstractSeries *series, QAxis *axisY)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->addSeries(series, axisY);
             }
             /*!
              Removes the \a series specified in a perameter from the QChartView.
              It releses its ownership of the specified QChartSeries object.
              It does not delete the pointed QChartSeries data object
              \sa addSeries(), removeAllSeries()
              */
             void QChart::removeSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->removeSeries(series);
             }
             /*!
              Removes all the QChartSeries that have been added to the QChartView
              It also deletes the pointed QChartSeries data objects
              \sa addSeries(), removeSeries()
              */
             void QChart::removeAllSeries()
             {
                 d_ptr->m_dataset->removeAllSeries();
             }
             /*!
              Sets the \a brush that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundBrush(const QBrush& brush)
             {
-                //TODO: refactor me
+                d_ptr->m_presenter->setBackgroundBrush(brush);
-                d_ptr->m_presenter->createChartBackgroundItem();
-                d_ptr->m_presenter->m_backgroundItem->setBrush(brush);
-                d_ptr->m_presenter->m_backgroundItem->update();
             }
             /*!
                 Gets the brush that is used for painting the background of the chart area.
              */
             QBrush QChart::backgroundBrush() const
             {
-                //TODO: refactor me
+                return d_ptr->m_presenter->backgroundBrush();
-                if (!d_ptr->m_presenter->m_backgroundItem) return QBrush();
-                return (d_ptr->m_presenter->m_backgroundItem)->brush();
             }
             /*!
              Sets the \a pen that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundPen(const QPen& pen)
             {
-                //TODO: refactor me
+                d_ptr->m_presenter->setBackgroundPen(pen);
-                d_ptr->m_presenter->createChartBackgroundItem();
-                d_ptr->m_presenter->m_backgroundItem->setPen(pen);
-                d_ptr->m_presenter->m_backgroundItem->update();
             }
             /*!
                 Gets the pen that is used for painting the background of the chart area.
              */
             QPen QChart::backgroundPen() const
             {
-                //TODO: refactor me
+                return d_ptr->m_presenter->backgroundPen();
-                if (!d_ptr->m_presenter->m_backgroundItem) return QPen();
-                return d_ptr->m_presenter->m_backgroundItem->pen();
             }
             /*!
              Sets the chart \a title. The description text that is drawn above the chart.
              */
             void QChart::setTitle(const QString& title)
             {
-                //TODO: refactor me
+                d_ptr->m_presenter->setTitle(title);
-                d_ptr->m_presenter->createChartTitleItem();
-                d_ptr->m_presenter->m_titleItem->setText(title);
-                d_ptr->m_presenter->updateLayout();
             }
             /*!
              Returns the chart title. The description text that is drawn above the chart.
              */
             QString QChart::title() const
             {
-                //TODO: refactor me
+                return d_ptr->m_presenter->title();
-                if (d_ptr->m_presenter->m_titleItem)
-                    return d_ptr->m_presenter->m_titleItem->text();
-                else
-                    return QString();
             }
             /*!
              Sets the \a font that is used for drawing the chart description text that is rendered above the chart.
              */
             void QChart::setTitleFont(const QFont& font)
             {
-                //TODO: refactor me
+                d_ptr->m_presenter->setTitleFont(font);
-                d_ptr->m_presenter->createChartTitleItem();
-                d_ptr->m_presenter->m_titleItem->setFont(font);
-                d_ptr->m_presenter->updateLayout();
             }
             /*!
                 Gets the font that is used for drawing the chart description text that is rendered above the chart.
              */
             QFont QChart::titleFont() const
             {
-                if (d_ptr->m_presenter->m_titleItem)
+                return d_ptr->m_presenter->titleFont();
-                    return d_ptr->m_presenter->m_titleItem->font();
-                else
-                    return QFont();
             }
             /*!
              Sets the \a brush used for rendering the title text.
              */
             void QChart::setTitleBrush(const QBrush &brush)
             {
-                //TODO: refactor me
+                d_ptr->m_presenter->setTitleBrush(brush);
-                d_ptr->m_presenter->createChartTitleItem();
-                d_ptr->m_presenter->m_titleItem->setBrush(brush);
-                d_ptr->m_presenter->updateLayout();
             }
             /*!
              Returns the brush used for rendering the title text.
              */
             QBrush QChart::titleBrush() const
             {
-                //TODO: refactor me
+                return d_ptr->m_presenter->titleBrush();
-                if (!d_ptr->m_presenter->m_titleItem) return QBrush();
-                return d_ptr->m_presenter->m_titleItem->brush();
             }
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 d_ptr->m_presenter->setTheme(theme);
             }
             QChart::ChartTheme QChart::theme() const
             {
                 return d_ptr->m_presenter->theme();
             }
             /*!
              Zooms in the view by a factor of 2
              */
             void QChart::zoomIn()
             {
                 d_ptr->m_presenter->zoomIn(2.0);
             }
             /*!
              Zooms in the view to a maximum level at which \a rect is still fully visible.
              */
             void QChart::zoomIn(const QRectF& rect)
             {
                 if (!rect.isValid()) return;
                 d_ptr->m_presenter->zoomIn(rect);
             }
             /*!
              Restores the view zoom level to the previous one.
              */
             void QChart::zoomOut()
             {
                 d_ptr->m_presenter->zoomOut(2.0);
             }
             /*!
              Zooms in the view by a \a factor.
              A factor over 1.0 zooms the view in and factor between 0.0 and 1.0 zooms out.
              */
             void QChart::zoom(qreal factor)
             {
                 if (qFuzzyIsNull(factor))
                     return;
                 if (qFuzzyCompare(factor, 1.0))
                     return;
                 if (factor < 0)
                     return;
                 if (factor > 1.0)
                     d_ptr->m_presenter->zoomIn(factor);
                 else
                     d_ptr->m_presenter->zoomOut(1.0 / factor);
             }
             /*!
              Returns the pointer to the x axis object of the chart
              */
             QAxis* QChart::axisX() const
             {
                 return d_ptr->m_dataset->axisX();
             }
             /*!
              Returns the pointer to the y axis object of the \a series
              If no \a series is provided then default Y axis of the chart is returned.
              */
             QAxis* QChart::axisY(QAbstractSeries *series) const
             {
                 return d_ptr->m_dataset->axisY(series);
             }
             /*!
              Returns the legend object of the chart. Ownership stays in chart.
              */
             QLegend* QChart::legend() const
             {
                 return d_ptr->m_legend;
             }
             /*!
                 Returns the rect that contains information about margins (distance between chart widget edge and axes).
                 Individual margins can be obtained by calling left, top, right, bottom on the returned rect.
              */
             QRectF QChart::margins() const
             {
                 return d_ptr->m_presenter->margins();
             }
             /*!
-             Resizes and updates the chart area using the \a event data
+             Sets animation \a options for the chart
              */
-            void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
-                d_ptr->m_rect = QRectF(QPoint(0,0),event->newSize());
-                QGraphicsWidget::resizeEvent(event);
-                d_ptr->m_presenter->setGeometry(d_ptr->m_rect);
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 d_ptr->m_presenter->setAnimationOptions(options);
             }
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return d_ptr->m_presenter->animationOptions();
             }
             /*!
                 Scrolls the visible area of the chart to the left by the distance between two x axis ticks
              */
             void QChart::scrollLeft()
             {
-                d_ptr->m_presenter->scroll(-d_ptr->m_presenter->chartGeometry().width()/(axisX()->ticksCount()-1),0);
+                d_ptr->m_presenter->scroll(-d_ptr->m_presenter->geometry().width()/(axisX()->ticksCount()-1),0);
             }
             /*!
                 Scrolls the visible area of the chart to the right by the distance between two x axis ticks
              */
             void QChart::scrollRight()
             {
-                d_ptr->m_presenter->scroll(d_ptr->m_presenter->chartGeometry().width()/(axisX()->ticksCount()-1),0);
+                d_ptr->m_presenter->scroll(d_ptr->m_presenter->geometry().width()/(axisX()->ticksCount()-1),0);
             }
             /*!
                 Scrolls the visible area of the chart up by the distance between two y axis ticks
              */
             void QChart::scrollUp()
             {
-                d_ptr->m_presenter->scroll(0,d_ptr->m_presenter->chartGeometry().width()/(axisY()->ticksCount()-1));
+                d_ptr->m_presenter->scroll(0,d_ptr->m_presenter->geometry().width()/(axisY()->ticksCount()-1));
             }
             /*!
                 Scrolls the visible area of the chart down by the distance between two y axis ticks
              */
             void QChart::scrollDown()
             {
-                d_ptr->m_presenter->scroll(0,-d_ptr->m_presenter->chartGeometry().width()/(axisY()->ticksCount()-1));
+                d_ptr->m_presenter->scroll(0,-d_ptr->m_presenter->geometry().width()/(axisY()->ticksCount()-1));
             }
             /*!
                 Scrolls the visible area of the chart by the distance defined in the \a delta.
              */
             void QChart::scroll(const QPointF &delta)
             {
                 d_ptr->m_presenter->scroll(-delta.x(), delta.y());
             }
             void QChart::setBackgroundVisible(bool visible)
             {
-                //TODO: refactor me
+                d_ptr->m_presenter->setBackgroundVisible(visible);
-                d_ptr->m_presenter->createChartBackgroundItem();
-                d_ptr->m_presenter->m_backgroundItem->setVisible(visible);
             }
             bool QChart::isBackgroundVisible() const
             {
-                //TODO: refactor me
+                return d_ptr->m_presenter->isBackgroundVisible();
-                if (!d_ptr->m_presenter->m_backgroundItem)
-                    return false;
-                return d_ptr->m_presenter->m_backgroundItem->isVisible();
             }
             void QChart::setDropShadowEnabled(bool enabled)
             {
-                d_ptr->m_presenter->createChartBackgroundItem();
+                d_ptr->m_presenter->setBackgroundDropShadowEnabled(enabled);
-                d_ptr->m_presenter->m_backgroundItem->setDropShadowEnabled(enabled);
             }
             bool QChart::isDropShadowEnabled() const
             {
-                if (!d_ptr->m_presenter->m_backgroundItem)
+                return d_ptr->m_presenter->isBackgroundDropShadowEnabled();
-                    return false;
-                return d_ptr->m_presenter->m_backgroundItem->isDropShadowEnabled();
             }
             /*!
               Returns all the series that are added to the chart.
               \sa addSeries(), removeSeries(), removeAllSeries()
             */
             QList<QAbstractSeries*> QChart::series() const
             {
                 return d_ptr->m_dataset->series();
             }
+            void QChart::setMarginsMinimum(const QRectF& margins)
+            {
+                d_ptr->m_presenter->setMarginsMinimum(margins);
+            }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartPrivate::QChartPrivate():
                 m_legend(0),
                 m_dataset(0),
                 m_presenter(0)
             {
             }
             QChartPrivate::~QChartPrivate()
             {
             }
             void QChartPrivate::createConnections()
             {
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QAbstractSeries*,Domain*)),m_presenter,SLOT(handleSeriesAdded(QAbstractSeries*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QAbstractSeries*)),m_presenter,SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QAxis*,Domain*)),m_presenter,SLOT(handleAxisAdded(QAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QAxis*)),m_presenter,SLOT(handleAxisRemoved(QAxis*)));
+                //QObject::connect(m_presenter, SIGNAL(marginsChanged(QRectF)), q_ptr, SIGNAL(marginsChanged(QRectF)));
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +2 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QCHART_H
             #define QCHART_H
             #include <QAbstractSeries>
             #include <QLegend>
             #include <QGraphicsWidget>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractSeries;
             class QAxis;
             class QLegend;
             struct QChartPrivate;
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
                 Q_PROPERTY(QChart::ChartTheme theme READ theme WRITE setTheme)
                 Q_PROPERTY(QString title READ title WRITE setTitle)
                 Q_PROPERTY(bool backgroundVisible READ isBackgroundVisible WRITE setBackgroundVisible)
                 Q_PROPERTY(bool dropShadowEnabled READ isDropShadowEnabled WRITE setDropShadowEnabled)
                 Q_PROPERTY(QChart::AnimationOptions animationOptions READ animationOptions WRITE setAnimationOptions)
                 Q_PROPERTY(QRectF margins READ margins NOTIFY marginsChanged)
                 Q_ENUMS(ChartTheme)
                 Q_ENUMS(AnimationOption)
             public:
                 enum ChartTheme {
                     ChartThemeLight = 0,
                     ChartThemeBlueCerulean,
                     ChartThemeDark,
                     ChartThemeBrownSand,
                     ChartThemeBlueNcs,
                     ChartThemeHighContrast,
                     ChartThemeBlueIcy
                 };
                 enum AnimationOption {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations =0x2,
                     AllAnimations = 0x3
                 };
                 Q_DECLARE_FLAGS(AnimationOptions, AnimationOption)
             public:
                 explicit QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
                 void addSeries(QAbstractSeries *series, QAxis *axisY = 0);
                 void removeSeries(QAbstractSeries *series);
                 void removeAllSeries();
                 QList<QAbstractSeries*> series() const;
                 void setTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme theme() const;
                 void setTitle(const QString& title);
                 QString title() const;
                 void setTitleFont(const QFont& font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundBrush(const QBrush &brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen &pen);
                 QPen backgroundPen() const;
                 void setBackgroundVisible(bool visible = true);
                 bool isBackgroundVisible() const;
                 void setDropShadowEnabled(bool enabled = true);
                 bool isDropShadowEnabled() const;
                 void setAnimationOptions(AnimationOptions options);
                 AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomIn(const QRectF &rect);
                 void zoomOut();
                 void zoom(qreal factor);
                 void scrollLeft();
                 void scrollRight();
                 void scrollUp();
                 void scrollDown();
                 void scroll(const QPointF &delta);
                 QAxis* axisX() const;
                 QAxis* axisY(QAbstractSeries* series = 0) const;
                 QLegend* legend() const;
+                void setMarginsMinimum(const QRectF& margins);
                 QRectF margins() const;
             Q_SIGNALS:
                 void marginsChanged(QRectF newMargins);
             protected:
-                void resizeEvent(QGraphicsSceneResizeEvent *event);
-            protected:
                 QScopedPointer<QChartPrivate> d_ptr;
                 friend class QLegend;
                 friend class ChartPresenter;
                 Q_DISABLE_COPY(QChart)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             Q_DECLARE_OPERATORS_FOR_FLAGS(QTCOMMERCIALCHART_NAMESPACE::QChart::AnimationOptions)
             #endif

src/qchart_p.h 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QCHART_P_H
             #define QCHART_P_H
             #include "qlegend.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             struct QChartPrivate
             {
                 QChartPrivate();
                 ~QChartPrivate();
-                QRectF m_rect;
                 QLegend* m_legend;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;
                 void createConnections();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/src.pro +4 -2

             !include( ../config.pri ):error( "Couldn't find the config.pri file!" )
             ############################# BUILD CONFIG ######################################
             TARGET = $$LIBRARY_NAME
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT = core gui
             DEFINES += QTCOMMERCIALCHART_LIBRARY
             win32:CONFIG += create_prl
             # treat warnings as errors
             win32-msvc*: {
                 QMAKE_CXXFLAGS += /WX
             } else {
                 QMAKE_CXXFLAGS += -Werror
             }
             unix:{
               QMAKE_CXXFLAGS += -fvisibility=hidden -fvisibility-inlines-hidden
             }
             # enable building debug and release at the same time
             CONFIG += debug_and_release
             # On windows by default build both debug and release at the same time
             win32:CONFIG += build_all
             ############################# DEPEDENCES ########################################
             win32-msvc*: LIBS += User32.lib
             LIBS -= -l$$LIBRARY_NAME
             INCLUDEPATH += ../include .
             ############################# SOURCES ##########################################
             SOURCES += \
                 $$PWD/chartdataset.cpp \
                 $$PWD/chartpresenter.cpp \
                 $$PWD/charttheme.cpp \
                 $$PWD/domain.cpp \
                 $$PWD/qchart.cpp \
                 $$PWD/qchartview.cpp \
                 $$PWD/qabstractseries.cpp \
                 $$PWD/chartbackground.cpp \
                 $$PWD/chart.cpp \
-                $$PWD/scroller.cpp
+                $$PWD/scroller.cpp \
+                $$PWD/chartlayout.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartdataset_p.h \
                 $$PWD/chartitem_p.h \
                 $$PWD/chartpresenter_p.h \
                 $$PWD/charttheme_p.h \
                 $$PWD/domain_p.h \
                 $$PWD/chartbackground_p.h \
                 $$PWD/chart_p.h \
                 $$PWD/chartconfig_p.h \
                 $$PWD/qchart_p.h \
                 $$PWD/qchartview_p.h \
                 $$PWD/scroller_p.h \
-                $$PWD/qabstractseries_p.h
+                $$PWD/qabstractseries_p.h \
+                $$PWD/chartlayout_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qchart.h \
                 $$PWD/qchartglobal.h \
                 $$PWD/qabstractseries.h \
                 $$PWD/qchartview.h
             include(animations/animations.pri)
             include(areachart/areachart.pri)
             include(axis/axis.pri)
             include(barchart/barchart.pri)
             include(legend/legend.pri)
             include(linechart/linechart.pri)
             include(piechart/piechart.pri)
             include(scatterchart/scatter.pri)
             include(splinechart/splinechart.pri)
             include(themes/themes.pri)
             include(xychart/xychart.pri)
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             ############################# BUILD PATH ##########################################
             OBJECTS_DIR = $$CHART_BUILD_DIR/lib
             MOC_DIR = $$CHART_BUILD_DIR/lib
             UI_DIR = $$CHART_BUILD_DIR/lib
             RCC_DIR = $$CHART_BUILD_DIR/lib
             ############################# PUBLIC HEADERS GENERTOR ##########################################
             #this is very primitive and lame parser , TODO: make perl script insted
             !exists($$CHART_BUILD_PUBLIC_HEADER_DIR/QChartGlobal)
             {
                 system($$QMAKE_MKDIR $$CHART_BUILD_PUBLIC_HEADER_DIR)
                  win32:{
                     command = "echo $${LITERAL_HASH}include \"qchartglobal.h\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/QChartGlobal"
                 }else{
                     command = "echo \"$${LITERAL_HASH}include \\\"qchartglobal.h\\\"\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/QChartGlobal"
                 }
                 PUBLIC_QT_HEADERS += $$CHART_BUILD_PUBLIC_HEADER_DIR/QChartGlobal
                 system($$command)
             }
             for(file, PUBLIC_HEADERS) {
                 name = $$split(file,'/')
                 name = $$last(name)
                 class = "$$cat($$file)"
                 class = $$find(class,class)
                 !isEmpty(class){
                 class = $$split(class,QTCOMMERCIALCHART_EXPORT)
                 class = $$member(class,1)
                 class = $$split(class,' ')
                 class = $$replace(class,' ','')
                 class = $$member(class,0)
                 win32:{
                     command = "echo $${LITERAL_HASH}include \"$$name\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/$$class"
                 }else{
                     command = "echo \"$${LITERAL_HASH}include \\\"$$name\\\"\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/$$class"
                 }
                 PUBLIC_QT_HEADERS += $$CHART_BUILD_PUBLIC_HEADER_DIR/$$class
                 system($$command)
                 }
             }
             ############################# INSTALLERS ##########################################
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS $$PUBLIC_QT_HEADERS
             INSTALLS += public_headers
             install_build_public_headers.name = build_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 = buld_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 \
             win32:{
                bintarget.CONFIG += no_check_exist
                !staticlib: {
                   bintarget.files += $$CHART_BUILD_LIB_DIR\\$${TARGET}.dll
                }
                win32-msvc*:CONFIG(debug, debug|release): {
                   bintarget.files += $$CHART_BUILD_LIB_DIR\\$${TARGET}.pdb
                }
                bintarget.path = $$[QT_INSTALL_BINS]
                libtarget.CONFIG += no_check_exist
                libtarget.files = $$CHART_BUILD_LIB_DIR\\$${TARGET}.prl
                win32-msvc*: {
                   libtarget.files += $$CHART_BUILD_LIB_DIR\\$${TARGET}.lib
                } else {
                   libtarget.files += $$CHART_BUILD_LIB_DIR\\lib$${TARGET}.a
                }
                libtarget.path = $$[QT_INSTALL_LIBS]
                DLLDESTDIR = $$CHART_BUILD_BIN_DIR
                INSTALLS += bintarget libtarget
             }else{
                target.path=$$[QT_INSTALL_LIBS]
                INSTALLS += target
             }
             mac: !staticlib: {
                 # Update the name (id) of the library on OSX to point to the lib path
                 MAC_CHARTS_LIB_NAME = "lib"$$LIBRARY_NAME".1.dylib"
                 QMAKE_POST_LINK += "install_name_tool -id $$CHART_BUILD_LIB_DIR"/"$$MAC_CHARTS_LIB_NAME $$CHART_BUILD_LIB_DIR"/"$$MAC_CHARTS_LIB_NAME"
                 # Update the name (id) of the installed library on OSX to point to the installation path
                 postinstall.path = $$[QT_INSTALL_LIBS]
                 postinstall.extra = "install_name_tool -id $$[QT_INSTALL_LIBS]"/"$$MAC_CHARTS_LIB_NAME $$[QT_INSTALL_LIBS]"/"$$MAC_CHARTS_LIB_NAME"
                 INSTALLS += postinstall
             }
             ################################ DEVELOPMENT BUILD ##########################################
             # There is a problem with jom.exe currently. It does not seem to understand QMAKE_EXTRA_TARGETS properly.
             # This is the case at least with shadow builds.
             # http://qt-project.org/wiki/jom
             development_build:!win32-msvc*:{
                 chartversion.target = $$PWD/qchartversion_p.h
                 unix:{
                     chartversion.commands = @echo \
                         \" $${LITERAL_HASH}ifndef QCHARTVERSION_P_H\\n\
                         $${LITERAL_HASH}define QCHARTVERSION_P_H\\n\
                         const char *buildTime = \\\"`date +'%y%m%d%H%M'`\\\" ; \\n\
                         const char *gitHead = \\\"`git rev-parse HEAD`\\\" ; \\n \
                         $${LITERAL_HASH}endif \"  \
                         > \
                         $$chartversion.target;
                 }else{
                     chartversion.commands = @echo \
                         "const char *buildTime = \"%date%_%time%\" ; \
                          const char *gitHead = \"unknown\" ; " \
                         > \
                         $$chartversion.target
                 }
                 chartversion.depends = $$HEADERS \
                     $$SOURCES
                 PRE_TARGETDEPS += $$chartversion.target
                 QMAKE_CLEAN += $$PWD/qchartversion_p.h
                 QMAKE_EXTRA_TARGETS += chartversion
             }
             ############################### CLEAN ###########################################
             unix:QMAKE_DISTCLEAN += -r \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             win32:QMAKE_DISTCLEAN += /Q \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             ############################## COVERAGE #########################################
             unix:coverage:{
             QMAKE_CXXFLAGS += -fprofile-arcs -ftest-coverage
             QMAKE_LDFLAGS += -fprofile-arcs -ftest-coverage
             LIBS += -lgcov
             QMAKE_CLEAN += $$OBJECTS_DIR/*.gcda $$OBJECTS_DIR/*.gcno $$PWD/*.gcov ../coverage/*.info
             QMAKE_EXTRA_TARGETS += preparecoverage gencoverage
             preparecoverage.target = prepare_coverage
             preparecoverage.depends = all
             preparecoverage.commands =  lcov --directory $$OBJECTS_DIR --zerocounters ;\
                                         lcov -i -d $$OBJECTS_DIR -c -o ../coverage/base.info -b $$PWD;
             gencoverage.target = gen_coverage
             gencoverage.depends = all
             gencoverage.commands = lcov -d $$OBJECTS_DIR -c -o ../coverage/src.info -b $$PWD;\
                                    lcov -e ../coverage/base.info $$PWD/* $$PWD/animations/* $$PWD/areachart/* $$PWD/axis/* $$PWD/barchart/* $$PWD/legend/* $$PWD/linechart/* $$PWD/piechart/* $$PWD/scatterchart/* $$PWD/splinechart/* $$PWD/themes/* $$PWD/xychart/* -o ../coverage/base.info;\
                                    lcov -e ../coverage/src.info $$PWD/* $$PWD/animations/* $$PWD/areachart/* $$PWD/axis/* $$PWD/barchart/* $$PWD/legend/* $$PWD/linechart/* $$PWD/piechart/* $$PWD/scatterchart/* $$PWD/splinechart/* $$PWD/themes/* $$PWD/xychart/* -o ../coverage/src.info;\
                                    lcov -a ../coverage/base.info -a ../coverage/src.info -o ../coverage/coverage.info;
             }

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