HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r855:e561e621da22

Refactor qledgend handling...

Michal Klocek -

r855:e561e621da22

parent child

Context file:

r855:e561e621da22

Expand all files

src/scroller.cpp created 644 +259 0

@@ -0,0 +1,259
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "scroller_p.h"
	22	#include "qlegend.h"
	23	#include <QGraphicsSceneMouseEvent>
	24
	25	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	26
	27	Scroller::Scroller(QLegend* legend):
	28	m_ticker(this),
	29	m_state(Idle),
	30	m_moveThreshold(10),
	31	m_timeTreshold(50),
	32	m_legend(legend)
	33	{
	34
	35	}
	36
	37	Scroller::~Scroller()
	38	{
	39	}
	40
	41	void Scroller::mousePressEvent(QGraphicsSceneMouseEvent* event)
	42	{
	43	if (event->button() == Qt::LeftButton) {
	44
	45	switch (m_state) {
	46	case Idle:
	47	{
	48	m_state = Pressed;
	49	m_offset = offset();
	50	m_press = event->pos();
	51	m_timeStamp = QTime::currentTime();
	52	event->accept();
	53	break;
	54	}
	55	case Scroll:
	56	{
	57	m_state = Stop;
	58	m_speed = QPoint(0, 0);
	59	m_offset = offset();
	60	m_press = event->pos();
	61	event->accept();
	62	break;
	63	}
	64	case Pressed:
	65	case Move:
	66	case Stop:
	67	qWarning() << __FUNCTION__<<"Scroller unexpected state" << m_state;
	68	event->ignore();
	69	break;
	70	}
	71	}
	72	}
	73
	74	void Scroller::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
	75	{
	76	QPointF delta = event->pos() - m_press;
	77
	78	switch (m_state) {
	79	case Pressed:
	80	case Stop:
	81	{
	82	if (qAbs(delta.x()) > m_moveThreshold \|\| qAbs(delta.y()) > m_moveThreshold) {
	83	m_state = Move;
	84	m_timeStamp = QTime::currentTime();
	85	m_distance = QPointF(0, 0);
	86	m_press = event->pos();
	87	event->accept();
	88	break;
	89	}
	90	else {
	91	event->ignore();
	92	break;
	93	}
	94	}
	95	case Move:
	96	{
	97	setOffset(m_offset - delta);
	98	calculateSpeed(event->pos());
	99	event->accept();
	100	break;
	101	}
	102	case Idle:
	103	case Scroll:
	104	qWarning() << __FUNCTION__<<"Scroller unexpected state" << m_state;
	105	event->ignore();
	106	break;
	107	}
	108
	109	}
	110
	111	void Scroller::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
	112	{
	113	if (event->button() == Qt::LeftButton) {
	114
	115	switch (m_state) {
	116
	117	case Scroll:
	118	m_state = Stop;
	119	m_speed = QPointF(0, 0);
	120	m_offset = offset();
	121	event->accept();
	122	break;
	123	case Pressed:
	124	{
	125	m_state = Idle;
	126	//if (m_timeStamp.elapsed() < m_clickedPressDelay) {
	127
	128	//emit clicked(m_offset.toPoint());
	129	//}
	130	event->accept();
	131	break;
	132	}
	133	case Move:
	134	{
	135	calculateSpeed(event->pos());
	136	m_offset = offset();
	137	m_press = event->pos();
	138	if (m_speed == QPointF(0, 0)) {
	139	m_state = Idle;
	140	}
	141	else {
	142	m_speed /= 4;
	143	m_state = Scroll;
	144	m_ticker.start(20);
	145	}
	146	event->accept();
	147	break;
	148	}
	149
	150	case Stop:
	151	case Idle:
	152	qWarning() << __FUNCTION__<<"Scroller unexpected state" << m_state;
	153	event->ignore();
	154	break;
	155
	156	}
	157	}
	158	}
	159
	160	void Scroller::scrollTick()
	161	{
	162	switch (m_state) {
	163	case Scroll:
	164	{
	165	lowerSpeed(m_speed);
	166	setOffset(m_offset - m_speed);
	167	m_offset = offset();
	168	if (m_speed == QPointF(0, 0)) {
	169	m_state = Idle;
	170	m_ticker.stop();
	171	}
	172	break;
	173	}
	174	case Stop:
	175	m_ticker.stop();
	176	break;
	177	case Idle:
	178	case Move:
	179	case Pressed:
	180	qWarning() << __FUNCTION__<<"Scroller unexpected state" << m_state;
	181	m_ticker.stop();
	182	break;
	183
	184	}
	185	}
	186
	187	void Scroller::lowerSpeed(QPointF& speed, qreal maxSpeed)
	188	{
	189	qreal x = qBound(-maxSpeed, speed.x(), maxSpeed);
	190	qreal y = qBound(-maxSpeed, speed.y(), maxSpeed);
	191
	192	x = (x == 0) ? x :
	193	(x > 0) ? qMax(qreal(0), x - m_fraction.x()) : qMin(qreal(0), x + m_fraction.x());
	194	y = (y == 0) ? y :
	195	(y > 0) ? qMax(qreal(0), y - m_fraction.y()) : qMin(qreal(0), y + m_fraction.y());
	196	speed.setX(x);
	197	speed.setY(y);
	198	}
	199
	200	void Scroller::calculateSpeed(const QPointF& position)
	201	{
	202	if (m_timeStamp.elapsed() > m_timeTreshold) {
	203
	204	QPointF distance = position - m_press;
	205
	206	m_timeStamp = QTime::currentTime();
	207	m_speed = distance - m_distance;
	208	m_distance = distance;
	209
	210	qreal fraction = qMax(qAbs(m_speed.x()), qAbs(m_speed.y()));
	211
	212	if (fraction != 0) {
	213	m_fraction.setX(qAbs(m_speed.x() / fraction));
	214	m_fraction.setY(qAbs(m_speed.y() / fraction));
	215	}
	216	else {
	217	m_fraction.setX(1);
	218	m_fraction.setY(1);
	219	}
	220	}
	221	}
	222
	223	void Scroller::setOffset(const QPointF& point)
	224	{
	225	m_legend->setOffset(point);
	226	}
	227
	228	QPointF Scroller::offset() const
	229	{
	230	return m_legend->offset();
	231	}
	232
	233	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	234
	235	ScrollTicker::ScrollTicker(Scroller scroller,QObject parent):QObject(parent),
	236	m_scroller(scroller)
	237	{
	238
	239	}
	240
	241	void ScrollTicker::start(int interval)
	242	{
	243	if (!m_timer.isActive()){
	244	m_timer.start(interval, this);
	245	}
	246	}
	247
	248	void ScrollTicker::stop()
	249	{
	250	m_timer.stop();
	251	}
	252
	253	void ScrollTicker::timerEvent(QTimerEvent *event)
	254	{
	255	Q_UNUSED(event);
	256	m_scroller->scrollTick();
	257	}
	258
	259	QTCOMMERCIALCHART_END_NAMESPACE

src/scroller_p.h created 644 +107 0

@@ -0,0 +1,107
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef SCROLLER_P_H_
	31	#define SCROLLER_P_H_
	32
	33	#include "qchartglobal.h"
	34	#include <QBasicTimer>
	35	#include <QTime>
	36	#include <QPointF>
	37
	38	class QGraphicsSceneMouseEvent;
	39
	40	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	41
	42	class Scroller;
	43	class QLegend;
	44
	45	class ScrollTicker : public QObject
	46	{
	47	public:
	48	ScrollTicker(Scroller scroller,QObject parent=0);
	49	void start(int interval);
	50	void stop();
	51	protected:
	52	void timerEvent(QTimerEvent *event);
	53
	54	private:
	55	QBasicTimer m_timer;
	56	Scroller *m_scroller;
	57	};
	58
	59	class Scroller
	60	{
	61	public:
	62	enum State {
	63	Idle,
	64	Pressed,
	65	Move,
	66	Scroll,
	67	Stop
	68	};
	69
	70	explicit Scroller(QLegend* legend);
	71	virtual ~Scroller();
	72
	73	virtual void setOffset(const QPointF& point);
	74	virtual QPointF offset() const;
	75
	76	public:
	77	void scrollTick();
	78
	79
	80	public:
	81	void mousePressEvent(QGraphicsSceneMouseEvent* event);
	82	void mouseMoveEvent(QGraphicsSceneMouseEvent* event);
	83	void mouseReleaseEvent(QGraphicsSceneMouseEvent* event);
	84
	85	private:
	86	void calculateSpeed(const QPointF& position);
	87	void lowerSpeed(QPointF& speed,qreal maxSpeed=100);
	88
	89	private:
	90	ScrollTicker m_ticker;
	91	State m_state;
	92	QTime m_timeStamp;
	93	QPointF m_press;
	94	QPointF m_offset;
	95	QPointF m_speed;
	96	QPointF m_distance;
	97	QPointF m_fraction;
	98	int m_moveThreshold;
	99	int m_timeTreshold;
	100	QLegend* m_legend;
	101
	102
	103	};
	104
	105	QTCOMMERCIALCHART_END_NAMESPACE
	106
	107	#endif /* SCROLLER_P_H_ */

demos/chartthemes/themewidget.cpp +11 -9

             /****************************************************************************
             **
             ** 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 "themewidget.h"
             #include <QChartView>
             #include <QPieSeries>
             #include <QPieSlice>
             #include <QBarSeries>
             #include <QPercentBarSeries>
             #include <QStackedBarSeries>
             #include <QBarSet>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QScatterSeries>
             #include <QAreaSeries>
             #include <QLegend>
             #include <QGridLayout>
             #include <QFormLayout>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGroupBox>
             #include <QLabel>
             #include <QTime>
             ThemeWidget::ThemeWidget(QWidget* parent) :
                 QWidget(parent),
                 m_listCount(3),
                 m_valueMax(10),
                 m_valueCount(7),
                 m_dataTable(generateRandomData(m_listCount,m_valueMax,m_valueCount)),
                 m_themeComboBox(createThemeBox()),
                 m_antialiasCheckBox(new QCheckBox("Anti-aliasing")),
                 m_animatedComboBox(createAnimationBox()),
                 m_legendComboBox(createLegendBox())
             {
                 connectSignals();
                 // create layout
                 QGridLayout* baseLayout = new QGridLayout();
                 QHBoxLayout *settingsLayout = new QHBoxLayout();
                 settingsLayout->addWidget(new QLabel("Theme:"));
                 settingsLayout->addWidget(m_themeComboBox);
                 settingsLayout->addWidget(new QLabel("Animation:"));
                 settingsLayout->addWidget(m_animatedComboBox);
+                settingsLayout->addWidget(new QLabel("Legend:"));
                 settingsLayout->addWidget(m_legendComboBox);
                 settingsLayout->addWidget(m_antialiasCheckBox);
                 settingsLayout->addStretch();
                 baseLayout->addLayout(settingsLayout, 0, 0, 1, 3);
                 //create charts
                 QChartView *chartView;
                 chartView = new QChartView(createAreaChart());
                 baseLayout->addWidget(chartView, 1, 0);
                 m_charts << chartView;
                 chartView = new QChartView(createBarChart(m_valueCount));
                 baseLayout->addWidget(chartView, 1, 1);
                 m_charts << chartView;
                 chartView = new QChartView(createLineChart());
                 baseLayout->addWidget(chartView, 1, 2);
                 m_charts << chartView;
                 chartView = new QChartView(createPieChart());
                 chartView->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored); // funny things happen if the pie slice labels no not fit the screen...
                 baseLayout->addWidget(chartView, 2, 0);
                 m_charts << chartView;
                 chartView = new QChartView(createSplineChart());
                 baseLayout->addWidget(chartView, 2, 1);
                 m_charts << chartView;
                 chartView = new QChartView(createScatterChart());
                 baseLayout->addWidget(chartView, 2, 2);
                 m_charts << chartView;
                 setLayout(baseLayout);
                 // Set defaults
                 m_antialiasCheckBox->setChecked(true);
+                updateUI();
             }
             ThemeWidget::~ThemeWidget()
             {
             }
             void ThemeWidget::connectSignals()
             {
                 connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 connect(m_antialiasCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 connect(m_animatedComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 connect(m_legendComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
             }
             DataTable ThemeWidget::generateRandomData(int listCount,int valueMax,int valueCount) const
             {
                 DataTable dataTable;
                 // set seed for random stuff
                 qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
                 // generate random data
                 for (int i(0); i < listCount; i++) {
                     DataList dataList;
                     qreal yValue(0);
                     for (int j(0); j < valueCount; j++) {
                         yValue = yValue + (qreal) (qrand() % valueMax) / (qreal) valueCount;
                         QPointF value((j + (qreal) rand() / (qreal) RAND_MAX) * ((qreal) m_valueMax / (qreal) valueCount),
                                       yValue);
                         QString label = "Item " + QString::number(i) + ":" + QString::number(j);
                         dataList << Data(value, label);
                     }
                     dataTable << dataList;
                 }
                 return dataTable;
             }
             QComboBox* ThemeWidget::createThemeBox() const
             {
                 // settings layout
                 QComboBox* themeComboBox = new QComboBox();
                 themeComboBox->addItem("Light", QChart::ChartThemeLight);
                 themeComboBox->addItem("Blue Cerulean", QChart::ChartThemeBlueCerulean);
                 themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                 themeComboBox->addItem("Brown Sand", QChart::ChartThemeBrownSand);
                 themeComboBox->addItem("Blue NCS", QChart::ChartThemeBlueNcs);
                 themeComboBox->addItem("High Contrast", QChart::ChartThemeHighContrast);
                 themeComboBox->addItem("Blue Icy", QChart::ChartThemeBlueIcy);
                 return themeComboBox;
             }
             QComboBox* ThemeWidget::createAnimationBox() const
             {
                 // settings layout
                 QComboBox* animationComboBox = new QComboBox();
                 animationComboBox->addItem("No Animations", QChart::NoAnimation);
                 animationComboBox->addItem("GridAxis Animations", QChart::GridAxisAnimations);
                 animationComboBox->addItem("Series Animations", QChart::SeriesAnimations);
                 animationComboBox->addItem("All Animations", QChart::AllAnimations);
                 return animationComboBox;
             }
             QComboBox* ThemeWidget::createLegendBox() const
             {
                 QComboBox* legendComboBox = new QComboBox();
-                legendComboBox->addItem("Legend None", -1);
+                legendComboBox->addItem("No Legend ", 0);
                 legendComboBox->addItem("Legend Top", QLegend::AlignmentTop);
                 legendComboBox->addItem("Legend Bottom", QLegend::AlignmentBottom);
                 legendComboBox->addItem("Legend Left", QLegend::AlignmentLeft);
                 legendComboBox->addItem("Legend Right", QLegend::AlignmentRight);
                 return legendComboBox;
             }
             QChart* ThemeWidget::createAreaChart() const
             {
                 // area chart
                 QChart *chart = new QChart();
                 chart->axisX()->setNiceNumbers(true);
                 chart->axisY()->setNiceNumbers(true);
                 chart->setTitle("Area chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 // The lower series initialized to zero values
                 QLineSeries *lowerSeries = 0;
                 for (int i(0); i < m_dataTable.count(); i++) {
                     QLineSeries *upperSeries = new QLineSeries(chart);
                     for (int j(0); j < m_dataTable[i].count(); j++) {
                         Data data = m_dataTable[i].at(j);
                         if (lowerSeries)
                             upperSeries->append(QPointF(j, lowerSeries->y(i) + data.first.y()));
                         else
                             upperSeries->append(QPointF(j, data.first.y()));
                     }
                     QAreaSeries *area = new QAreaSeries(upperSeries, lowerSeries);
                     area->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(area);
                     lowerSeries = upperSeries;
                 }
                 return chart;
             }
             QChart* ThemeWidget::createBarChart(int valueCount) const
             {
                 // bar chart
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbers(true);
                 chart->axisY()->setNiceNumbers(true);
                 chart->setTitle("Bar chart");
                 QBarCategories categories;
                 // TODO: categories
                 for (int i(0); i < valueCount; i++)
                     categories << QString::number(i);
             //            QBarSeries* series = new QBarSeries(categories, chart);
             //            QPercentBarSeries* series = new QPercentBarSeries(categories, chart);
                 QStackedBarSeries* series = new QStackedBarSeries(categories, chart);
                 for (int i(0); i < m_dataTable.count(); i++) {
                     QBarSet *set = new QBarSet("Set" + QString::number(i));
                     foreach (Data data, m_dataTable[i])
                         *set << data.first.y();
                     series->appendBarSet(set);
                 }
                 chart->addSeries(series);
                 return chart;
             }
             QChart* ThemeWidget::createLineChart() const
             {
                 // line chart
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbers(true);
                 chart->axisY()->setNiceNumbers(true);
                 chart->setTitle("Line chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QLineSeries *series = new QLineSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createPieChart() const
             {
                 // pie chart
                 QChart* chart = new QChart();
                 chart->setTitle("Pie chart");
                 qreal pieSize = 1.0 / m_dataTable.count();
                 for (int i = 0; i < m_dataTable.count(); i++) {
                     QPieSeries *series = new QPieSeries(chart);
                     foreach (Data data, m_dataTable[i]) {
                         QPieSlice *slice = series->append(data.first.y(), data.second);
                         if (data == m_dataTable[i].first()) {
                             slice->setLabelVisible();
                             slice->setExploded();
                         }
                     }
                     qreal hPos = (pieSize / 2) + (i / (qreal) m_dataTable.count());
                     series->setPieSize(pieSize);
                     series->setPiePosition(hPos, 0.5);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createSplineChart() const
             { // spine chart
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbers(true);
                 chart->axisY()->setNiceNumbers(true);
                 chart->setTitle("Spline chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QSplineSeries *series = new QSplineSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createScatterChart() const
             { // scatter chart
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbers(true);
                 chart->axisY()->setNiceNumbers(true);
                 chart->setTitle("Scatter chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QScatterSeries *series = new QScatterSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 return chart;
             }
             void ThemeWidget::updateUI()
             {
                 QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(m_themeComboBox->currentIndex()).toInt();
                 if (m_charts.at(0)->chart()->theme() != theme) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setTheme(theme);
                     QPalette pal = window()->palette();
                     if (theme == QChart::ChartThemeLight) {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeDark) {
                         pal.setColor(QPalette::Window, QRgb(0x121218));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBlueCerulean) {
                         pal.setColor(QPalette::Window, QRgb(0x40434a));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBrownSand) {
                         pal.setColor(QPalette::Window, QRgb(0x9e8965));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeBlueNcs) {
                         pal.setColor(QPalette::Window, QRgb(0x018bba));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeHighContrast) {
                         pal.setColor(QPalette::Window, QRgb(0xffab03));
                         pal.setColor(QPalette::WindowText, QRgb(0x181818));
                     } else if (theme == QChart::ChartThemeBlueIcy) {
                         pal.setColor(QPalette::Window, QRgb(0xcee7f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     }
                     window()->setPalette(pal);
                 }
                 bool checked = m_antialiasCheckBox->isChecked();
                 foreach (QChartView *chart, m_charts)
                     chart->setRenderHint(QPainter::Antialiasing, checked);
                 QChart::AnimationOptions options(m_animatedComboBox->itemData(m_animatedComboBox->currentIndex()).toInt());
                 if (m_charts.at(0)->chart()->animationOptions() != options) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setAnimationOptions(options);
                 }
-                int alignment(m_legendComboBox->itemData(m_legendComboBox->currentIndex()).toInt());
+                QLegend::Alignments alignment(m_legendComboBox->itemData(m_legendComboBox->currentIndex()).toInt());
-                if (alignment == -1) {
+                if (!alignment) {
                     foreach (QChartView *chartView, m_charts) {
-                        chartView->chart()->legend()->setVisible(false);
+                        chartView->chart()->legend()->hide();
                     }
-                } else {
-                    QLegend::Alignments legendAlignment(alignment);
+                else
                     foreach (QChartView *chartView, m_charts) {
-                        chartView->chart()->legend()->setAlignmnent(legendAlignment);
+                        chartView->chart()->legend()->setAlignmnent(alignment);
-                        chartView->chart()->legend()->setVisible(true);
+                        chartView->chart()->legend()->show();
                     }
             }

src/areachart/qareaseries.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$
             **
             ****************************************************************************/
             #ifndef QAREASERIES_H_
             #define QAREASERIES_H_
             #include <qchartglobal.h>
             #include <qseries.h>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLineSeries;
             class QTCOMMERCIALCHART_EXPORT QAreaSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries = 0);
                 virtual ~QAreaSeries();
             public: // from QChartSeries
                 virtual QSeriesType type() const { return QSeries::SeriesTypeArea; }
                 QLineSeries* upperSeries() const { return m_upperSeries; }
                 QLineSeries* lowerSeries() const { return m_lowerSeries; }
                 void setPen(const QPen &pen);
                 QPen pen() const { return m_pen;}
                 void setBrush(const QBrush &brush);
                 QBrush brush() const { return m_brush;}
                 void setPointsVisible(bool visible);
                 bool pointsVisible() const { return m_pointsVisible; }
             //    bool setModel(QAbstractItemModel* model);
             //    void setModelMappingUpper(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
             //    void setModelMappingLower(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
             Q_SIGNALS:
                 void updated();
                 void clicked(const QPointF &point);
+                void selected();
             private:
                 QBrush m_brush;
                 QPen m_pen;
                 QLineSeries* m_upperSeries;
                 QLineSeries* m_lowerSeries;
                 bool m_pointsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/axis/axisitem.cpp +34 -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 "axisitem_p.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QDebug>
             #include <cmath>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Axis::Axis(QChartAxis *axis,ChartPresenter *presenter,AxisType type) : Chart(presenter),
                 m_chartAxis(axis),
                 m_type(type),
                 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)
             {
                 //initial initialization
                 m_axis->setZValue(ChartPresenter::AxisZValue);
                 m_axis->setHandlesChildEvents(false);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 connect(m_chartAxis,SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
                 connect(m_chartAxis->categories(),SIGNAL(updated()),this,SLOT(handleAxisCategoriesUpdated()));
                 handleAxisUpdated();
             }
             Axis::~Axis()
             {
             }
             void Axis::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 Axis::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 Axis::updateLayout(QVector<qreal> &layout)
             {
                 if (animator()) {
                     animator()->updateLayout(this,layout);
                 } else {
                     setLayout(layout);
                 }
             }
             bool Axis::createLabels(QStringList &labels,qreal min, qreal max,int ticks) const
             {
                 Q_ASSERT(max>=min);
                 Q_ASSERT(ticks>1);
                 QChartAxisCategories* 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));
                         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 Axis::setAxisOpacity(qreal opacity)
             {
                 m_axis->setOpacity(opacity);
             }
             qreal Axis::axisOpacity() const
             {
                 return m_axis->opacity();
             }
             void Axis::setGridOpacity(qreal opacity)
             {
                 m_grid->setOpacity(opacity);
             }
             qreal Axis::gridOpacity() const
             {
                 return m_grid->opacity();
             }
             void Axis::setLabelsOpacity(qreal opacity)
             {
                 m_labels->setOpacity(opacity);
             }
             qreal Axis::labelsOpacity() const
             {
                 return m_labels->opacity();
             }
             void Axis::setShadesOpacity(qreal opacity)
             {
                 m_shades->setOpacity(opacity);
             }
             qreal Axis::shadesOpacity() const
             {
                 return m_shades->opacity();
             }
             void Axis::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
             void Axis::setLabelsPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
             void Axis::setLabelsBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
             void Axis::setLabelsFont(const QFont &font)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
             }
             void Axis::setShadesBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
             void Axis::setShadesPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
             void Axis::setAxisPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_axis->childItems()) {
                        static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             void Axis::setGridPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_grid->childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             QVector<qreal> Axis::calculateLayout() const
             {
                 Q_ASSERT(m_ticksCount>=2);
                 QVector<qreal> points;
                 points.resize(m_ticksCount);
                 switch (m_type)
                 {
                     case X_AXIS:
                     {
                         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;
                         }
                     }
                     break;
                     case Y_AXIS:
                     {
                         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;
                         }
                     }
                     break;
                 }
                 return points;
             }
             void Axis::setLayout(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();
             	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;
             	switch (m_type)
             	{
             		case X_AXIS:
             		{
             			QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
             			lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
             			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));
-            				    QPointF center = labelItem->boundingRect().center();
+            				    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);
                             } else {
             				    labelItem->setText(ticksList.at(i));
-            				    QPointF center = labelItem->boundingRect().center();
+            			        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);
             				}
                             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);
             			}
             		}
             		break;
             		case Y_AXIS:
             		{
             			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));
-            				    QPointF center = labelItem->boundingRect().center();
+            				    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() - labelItem->boundingRect().width() - label_padding , layout[i]-center.y());
+            				    labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
                             } else {
             				    labelItem->setText(ticksList.at(i));
-            				    QPointF center = labelItem->boundingRect().center();
+            				    const QRectF& rect = labelItem->boundingRect();
+            				    minWidth=qMax(rect.width(),minWidth);
+            				    minHeight+=rect.height();
+            				    QPointF center = rect.center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
-            				    labelItem->setPos(m_rect.left() - labelItem->boundingRect().width() - label_padding , layout[i] - (layout[i] - layout[i-1])/2 -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]);
             			}
             		}
             		break;
             		default:
                     qDebug()<<"Unknown axis type";
             		break;
             	}
-            	m_layoutVector=layout;
+                m_layoutVector=layout;
+                presenter()->setMinimumMarginWidth(this,minWidth);
+                presenter()->setMinimumMarginHeight(this,minHeight);
             }
             bool Axis::isEmpty()
             {
                 return m_rect.isEmpty() || qFuzzyIsNull(m_min - m_max) || m_ticksCount==0;
             }
             //handlers
             void Axis::handleAxisCategoriesUpdated()
             {
                 if (isEmpty()) return;
             	updateLayout(m_layoutVector);
             }
             void Axis::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(m_chartAxis->shadesOpacity());
                 } 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 Axis::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 Axis::handleGeometryChanged(const QRectF &rect)
             {
-                m_rect = rect;
+                if(m_rect != rect)
-                if (isEmpty()) return;
-                QVector<qreal> layout = calculateLayout();
+                    m_rect = rect;
-                updateLayout(layout);
+                    if (isEmpty()) return;
+                    QVector<qreal> layout = calculateLayout();
+                    updateLayout(layout);
+                }
             }
             void Axis::axisSelected()
             {
                 qDebug()<<"TODO axis clicked";
             }
             //TODO "nice numbers algorithm"
             #include "moc_axisitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/axisitem_p.h +1 -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$
             **
             ****************************************************************************/
             #ifndef AXISITEM_H_
             #define AXISITEM_H_
+            #include "qchartglobal.h"
             #include "chart_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxis;
             class ChartPresenter;
             class Axis : public Chart
             {
                 Q_OBJECT
             public:
                 enum AxisType{X_AXIS,Y_AXIS};
                 Axis(QChartAxis *axis, ChartPresenter *presenter, AxisType type = X_AXIS);
                 ~Axis();
                 AxisType axisType() const { return m_type; }
                 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);
                 inline QRectF geometry() const { return m_rect; }
                 inline QVector<qreal> layout() { return m_layoutVector; }
             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);
                 QVector<qreal> calculateLayout() const;
                 void updateLayout(QVector<qreal> &layout);
                 void setLayout(QVector<qreal> &layout);
                 bool createLabels(QStringList &labels,qreal min, qreal max,int ticks) const;
                 void axisSelected();
             private:
                 QChartAxis* m_chartAxis;
                 AxisType m_type;
                 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;
-                qreal m_zoomFactor;
                 friend class AxisAnimation;
                 friend class AxisItem;
             };
             class AxisItem: public QGraphicsLineItem
             {
             public:
                 AxisItem(Axis *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()!=Axis::X_AXIS?8:0,m_axis->axisType()!=Axis::Y_AXIS?8:0));
                    return path;
                }
             private:
                Axis* m_axis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/barchart/qbarseries.h +1 -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$
             **
             ****************************************************************************/
             #ifndef BARSERIES_H
             #define BARSERIES_H
             #include <qseries.h>
             #include <QStringList>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             typedef QStringList QBarCategories;
             class QBarSet;
             class BarChartModel;
             class BarCategory;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QBarSeries(QStringList categories, QObject *parent = 0);
                 virtual QSeriesType type() const { return QSeries::SeriesTypeBar; }
                 void appendBarSet(QBarSet *set);            // Takes ownership of set
                 void removeBarSet(QBarSet *set);            // Releases ownership, doesn't delete set
                 void appendBarSets(QList<QBarSet* > sets);
                 void removeBarSets(QList<QBarSet* > sets);
                 void insertBarSet(int i, QBarSet *set);
                 void insertCategory(int i, QString category);
                 void removeCategory(int i);
                 int barsetCount() const;
                 int categoryCount() const;
                 QList<QBarSet*> barSets() const;
                 QBarCategories categories() const;
                 void setLabelsVisible(bool visible = true);
                 bool setModel(QAbstractItemModel *model);
                 QAbstractItemModel *modelExt() { return m_model; }
                 void setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation = Qt::Vertical);
                 void setModelMappingShift(int first, int count);
             public:
                 // TODO: Functions below this are not part of api and will be moved
                 // to private implementation, when we start using it
                 // TODO: TO PIMPL --->
                 QBarSet* barsetAt(int index);
                 QString categoryName(int category);
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal absoluteCategorySum(int category);
                 qreal maxCategorySum();
                 BarChartModel& model();
                 // <--- TO PIMPL
             Q_SIGNALS:
                 void clicked(QBarSet *barset, QString category, Qt::MouseButtons button);        // Up to user of api, what to do with these signals
+                void selected();
                 //
                 void updatedBars();
                 void restructuredBars();
                 // TODO: internal signals, these to private implementation.
                 // TODO: TO PIMPL --->
                 void showToolTip(QPoint pos, QString tip);
                 // <--- TO PIMPL
             public Q_SLOTS:
                 void setToolTipEnabled(bool enabled = true);           // enables tooltips
                 // TODO: TO PIMPL --->
                 void barsetClicked(QString category, Qt::MouseButtons button);
                 // <--- TO PIMPL
             private Q_SLOTS:
                 // slots for updating bars when data in model changes
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelDataAdded(QModelIndex parent, int start, int end);
                 void modelDataRemoved(QModelIndex parent, int start, int end);
                 void barsetChanged();
             protected:
                 BarChartModel *m_internalModel;     // TODO: this may change... current "2 models" situation doesn't look good.
                 QAbstractItemModel* m_model;
                 int m_mapCategories;
                 int m_mapBarBottom;
                 int m_mapBarTop;
                 int m_mapFirst;
                 int m_mapCount;
                 Qt::Orientation m_mapOrientation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/chartpresenter.cpp +169 -37

             /****************************************************************************
             **
             ** 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 "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             //series
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "areachartitem_p.h"
             #include "barchartitem_p.h"
             #include "stackedbarchartitem_p.h"
             #include "percentbarchartitem_p.h"
             #include "linechartitem_p.h"
             #include "piechartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "splinechartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
                 m_chart(chart),
                 m_animator(0),
                 m_dataset(dataset),
                 m_chartTheme(0),
-                m_rect(QRectF(QPoint(0,0),m_chart->size())),
+                m_chartRect(QRectF(QPoint(0,0),m_chart->size())),
                 m_options(QChart::NoAnimation),
                 m_themeForce(false),
-                m_backgroundPadding(10)
+                m_minLeftMargin(0),
+                m_minBottomMargin(0),
+                m_backgroundItem(0),
+                m_titleItem(0),
+                m_marginBig(60),
+                m_marginSmall(20),
+                m_marginTiny(10),
+                m_chartMargins(QRect(m_marginBig,m_marginBig,0,0))
             {
                 createConnections();
                 setTheme(QChart::ChartThemeLight, false);
             }
             ChartPresenter::~ChartPresenter()
             {
             	delete m_chartTheme;
             }
             void ChartPresenter::createConnections()
             {
-                QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),this,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*,Domain*)),this,SLOT(handleAxisAdded(QChartAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
             }
-            void ChartPresenter::handleGeometryChanged()
+            void ChartPresenter::setGeometry(const QRectF& rect)
             {
-                QRectF rect(QPoint(0,0),m_chart->size());
-                QRectF padding = m_chart->padding();
-                rect.adjust(padding.left(), padding.top(), -padding.right(), -padding.bottom());
-                //rewrite zoom stack
-                /*
-                for(int i=0;i<m_zoomStack.count();i++){
-                    QRectF r = m_zoomStack[i];
-                    qreal w = rect.width()/m_rect.width();
-                    qreal h = rect.height()/m_rect.height();
-                    QPointF tl = r.topLeft();
-                    tl.setX(tl.x()*w);
-                    tl.setY(tl.y()*h);
-                    QPointF br = r.bottomRight();
-                    br.setX(br.x()*w);
-                    br.setY(br.y()*h);
-                    r.setTopLeft(tl);
-                    r.setBottomRight(br);
-                    m_zoomStack[i]=r;
-                */
                 m_rect = rect;
                 Q_ASSERT(m_rect.isValid());
-                emit geometryChanged(m_rect);
+                updateLayout();
+            }
+            void ChartPresenter::setMinimumMarginWidth(Axis* axis, qreal width)
+            {
+                switch(axis->axisType()){
+                    case Axis::X_AXIS:
+                    {
+                        if(width>m_chartRect.width()+ m_chartMargins.left()) {
+                            m_minLeftMargin= width - m_chartRect.width();
+                            updateLayout();
+                        }
+                        break;
+                    }
+                    case Axis::Y_AXIS:
+                    {
+                        if(m_minLeftMargin!=width){
+                            m_minLeftMargin= width;
+                            updateLayout();
+                        }
+                        break;
+                    }
+                }
+            }
+            void ChartPresenter::setMinimumMarginHeight(Axis* axis, qreal height)
+            {
+                switch(axis->axisType()){
+                    case Axis::X_AXIS:
+                    {
+                        if(m_minBottomMargin!=height) {
+                            m_minBottomMargin= height;
+                            updateLayout();
+                        }
+                        break;
+                    }
+                    case Axis::Y_AXIS:
+                    {
+                        if(height>m_chartMargins.bottom()+m_chartRect.height()){
+                            m_minBottomMargin= height - m_chartRect.height();
+                           updateLayout();
+                        }
+                        break;
+                    }
+                }
             }
             void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain)
             {
                 Axis* item = new Axis(axis,this,axis==m_dataset->axisX()?Axis::X_AXIS : Axis::Y_AXIS);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     m_animator->addAnimation(item);
                 }
                 if(axis==m_dataset->axisX()){
                     m_chartTheme->decorate(axis,true,m_themeForce);
                     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,m_themeForce);
                     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(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 //initialize
-                item->handleGeometryChanged(m_rect);
+                item->handleGeometryChanged(m_chartRect);
                 m_axisItems.insert(axis, item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 Axis* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
             {
             	Chart *item = 0 ;
                 switch(series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     LineChartItem* line = new LineChartItem(lineSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                     	m_animator->addAnimation(line);
                     }
                     m_chartTheme->decorate(lineSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),line,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),line,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item = line;
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                     AreaChartItem* area = new AreaChartItem(areaSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(area->upperLineItem());
                         if(areaSeries->lowerSeries())  m_animator->addAnimation(area->lowerLineItem());
                     }
                     m_chartTheme->decorate(areaSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),area,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),area,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=area;
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     BarChartItem* bar = new BarChartItem(barSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(barSeries, m_dataset->seriesIndex(barSeries),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     StackedBarChartItem* bar = new StackedBarChartItem(stackedBarSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(stackedBarSeries, m_dataset->seriesIndex(stackedBarSeries),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     PercentBarChartItem* bar = new PercentBarChartItem(percentBarSeries,this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(percentBarSeries, m_dataset->seriesIndex(percentBarSeries),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                 	QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
                         ScatterChartItem *scatter = new ScatterChartItem(scatterSeries,this);
                         if(m_options.testFlag(QChart::SeriesAnimations)) {
                             m_animator->addAnimation(scatter);
                         }
                         m_chartTheme->decorate(scatterSeries, m_dataset->seriesIndex(series),m_themeForce);
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),scatter,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),scatter,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                         item = scatter;
                         break;
             	}
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     PieChartItem* pie = new PieChartItem(pieSeries, this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(pie);
                     }
                     m_chartTheme->decorate(pieSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),pie,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),pie,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     // Hide all from background when there is only piechart
                     // TODO: refactor this ugly code... should be one setting for this
                     if (m_chartItems.count() == 0) {
                         m_chart->axisX()->hide();
                         m_chart->axisY()->hide();
                     }
                     item=pie;
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
                     SplineChartItem* spline  = new SplineChartItem(splineSeries, this);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(spline);
                     }
                     m_chartTheme->decorate(splineSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),spline,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),spline,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=spline;
                     break;
                 }
                 default: {
                     qDebug()<< "Series type" << series->type() << "not implemented.";
                     break;
                 }
                 }
                 //initialize
                 item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
-                if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
+                if(m_chartRect.isValid()) item->handleGeometryChanged(m_chartRect);
                 m_chartItems.insert(series,item);
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
                 Chart* item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 if(m_animator) {
                     //small hack to handle area animations
                     if(series->type()==QSeries::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_themeForce = force;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart,m_themeForce);
                 m_chartTheme->decorate(m_chart->legend(),m_themeForce);
                 resetAllElements();
             }
             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<QChartAxis*> axisList = m_axisItems.uniqueKeys();
                  QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
                  foreach(QChartAxis* axis, axisList) {
                      handleAxisRemoved(axis);
                      handleAxisAdded(axis,m_dataset->domain(axis));
                  }
                  foreach(QSeries* series, seriesList) {
                      handleSeriesRemoved(series);
                      handleSeriesAdded(series,m_dataset->domain(series));
                  }
             }
             void ChartPresenter::zoomIn()
             {
-            	QRectF rect = geometry();
+            	QRectF rect = chartGeometry();
             	rect.setWidth(rect.width()/2);
             	rect.setHeight(rect.height()/2);
-            	rect.moveCenter(geometry().center());
+            	rect.moveCenter(chartGeometry().center());
             	zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
             	QRectF r = rect.normalized();
-                r.translate(-m_chart->padding().topLeft());
+                r.translate(-m_chartMargins.topLeft());
             	if(m_animator) {
-            		QPointF point(r.center().x()/geometry().width(),r.center().y()/geometry().height());
+            		QPointF point(r.center().x()/chartGeometry().width(),r.center().y()/chartGeometry().height());
             		m_animator->setState(ChartAnimator::ZoomInState,point);
             	}
-            	m_dataset->zoomInDomain(r,geometry().size());
+            	m_dataset->zoomInDomain(r,chartGeometry().size());
             	if(m_animator) {
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::zoomOut()
             {
             	if(m_animator)
             	{
             		m_animator->setState(ChartAnimator::ZoomOutState);
             	}
-            	QSizeF size = geometry().size();
+            	QSizeF size = chartGeometry().size();
-            	QRectF rect = geometry();
+            	QRectF rect = chartGeometry();
-                rect.translate(-m_chart->padding().topLeft());
+                rect.translate(-m_chartMargins.topLeft());
                 m_dataset->zoomOutDomain(rect.adjusted(size.width()/4,size.height()/4,-size.width()/4,-size.height()/4),size);
                 //m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
             	if(m_animator){
             			m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::scroll(int dx,int dy)
             {
             	if(m_animator){
             		if(dx<0) m_animator->setState(ChartAnimator::ScrollLeftState,QPointF());
             		if(dx>0) m_animator->setState(ChartAnimator::ScrollRightState,QPointF());
             		if(dy<0) m_animator->setState(ChartAnimator::ScrollUpState,QPointF());
             		if(dy>0) m_animator->setState(ChartAnimator::ScrollDownState,QPointF());
             	}
-            	m_dataset->scrollDomain(dx,dy,geometry().size());
+            	m_dataset->scrollDomain(dx,dy,chartGeometry().size());
                 if(m_animator){
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
+            void ChartPresenter::updateLayout()
+            {
+                if (!m_rect.isValid()) return;
+                // recalculate title size
+                QSize titleSize;
+                int titlePadding=0;
+                if (m_titleItem) {
+                    titleSize= m_titleItem->boundingRect().size().toSize();
+                }
+                //defaults
+                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;
+                QLegend* legend = m_chart->d_ptr->m_legend;
+                // recalculate legend position
+                if (legend->isAttachedToChart() && legend->isEnabled()) {
+                    QRect legendRect;
+                    // Reserve some space for legend
+                    switch (legend->alignment()) {
+                        case QLegend::AlignmentTop: {
+                            int ledgendSize = legend->minHeight();
+                            int topPadding = 2*m_marginTiny + titleSize.height() + ledgendSize + m_marginTiny;
+                            m_chartMargins = QRect(QPoint(m_chartMargins.left(),topPadding),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
+                            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 QLegend::AlignmentBottom: {
+                            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 QLegend::AlignmentLeft: {
+                            int ledgendSize = legend->minWidht();
+                            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 QLegend::AlignmentRight: {
+                            int ledgendSize = legend->minWidht();
+                            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;
+                        }
+                    }
+                }
+                // recalculate title position
+                if (m_titleItem) {
+                    QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
+                    m_titleItem->setPos(center.x(),titlePadding);
+                }
+                //recalculate background gradient
+                if (m_backgroundItem) {
+                    m_backgroundItem->setRect(m_rect.adjusted(m_marginTiny,m_marginTiny, -m_marginTiny, -m_marginTiny));
+                }
+               m_chartRect = m_rect.adjusted(m_chartMargins.left(),m_chartMargins.top(),-m_chartMargins.right(),-m_chartMargins.bottom());
+               emit geometryChanged(m_chartRect);
+               legend->setGeometry(m_rect.adjusted(m_legendMargins.left(),m_legendMargins.top(),-m_legendMargins.right(),-m_legendMargins.bottom()));
+            }
+            void ChartPresenter::createChartBackgroundItem()
+            {
+                if (!m_backgroundItem) {
+                    m_backgroundItem = new ChartBackground(rootItem());
+                    m_backgroundItem->setPen(Qt::NoPen);
+                    m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
+                }
+            }
+            void ChartPresenter::createChartTitleItem()
+            {
+                if (!m_titleItem) {
+                    m_titleItem = new QGraphicsSimpleTextItem(rootItem());
+                    m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
+                }
+            }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +26 -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 CHARTPRESENTER_H_
             #define CHARTPRESENTER_H_
             #include "qchartglobal.h"
+            #include "chartbackground_p.h" //TODO fix me
             #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
             #include "qchartaxis.h"
             #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Chart;
             class QSeries;
             class ChartDataSet;
             class Domain;
             class Axis;
             class ChartTheme;
             class ChartAnimator;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     ShadesZValue,
                     GridZValue,
                     LineChartZValue,
                     BarSeriesZValue,
                     ScatterSeriesZValue,
                     PieSeriesZValue,
                     AxisZValue,
                     LegendZValue
                 };
                 ChartPresenter(QChart* chart,ChartDataSet *dataset);
                 virtual ~ChartPresenter();
-                int backgroundPadding() const { return m_backgroundPadding; }
-                QRectF geometry() const { return m_rect; }
                 ChartAnimator* animator() const { return m_animator; }
                 ChartTheme *chartTheme() const { return m_chartTheme; }
                 ChartDataSet *dataSet() const { return m_dataset; }
                 QGraphicsItem* rootItem() const { return m_chart; }
                 void setTheme(QChart::ChartTheme theme,bool force = true);
                 QChart::ChartTheme theme();
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomIn(const QRectF& rect);
                 void zoomOut();
                 void scroll(int dx,int dy);
-            private:
+                void setGeometry(const QRectF& rect);
+                QRectF chartGeometry() const { return m_chartRect; }
+                void setMinimumMarginHeight(Axis* axis, qreal height);
+                void setMinimumMarginWidth(Axis* axis, qreal width);
+                qreal minimumLeftMargin() const { return m_minLeftMargin; }
+                qreal minimumBottomMargin() const { return m_minBottomMargin; }
+            public: //TODO: fix me
                 void createConnections();
                 void resetAllElements();
+                void createChartBackgroundItem();
+                void createChartTitleItem();
+                QRect margins() const { return m_chartMargins;}
             public Q_SLOTS:
                 void handleSeriesAdded(QSeries* series,Domain* domain);
                 void handleSeriesRemoved(QSeries* series);
                 void handleAxisAdded(QChartAxis* axis,Domain* domain);
                 void handleAxisRemoved(QChartAxis* axis);
-                void handleGeometryChanged();
+                void updateLayout();
             Q_SIGNALS:
                 void geometryChanged(const QRectF& rect);
             private:
                 QChart* m_chart;
                 ChartAnimator* m_animator;
                 ChartDataSet* m_dataset;
                 ChartTheme *m_chartTheme;
                 QMap<QSeries*,Chart*> m_chartItems;
                 QMap<QChartAxis*,Axis*> m_axisItems;
                 QRectF m_rect;
+                QRectF m_chartRect;
                 QChart::AnimationOptions m_options;
                 bool m_themeForce;
-                int m_backgroundPadding;
+                qreal m_minLeftMargin;
+                qreal m_minBottomMargin;
+            public: //TODO: fixme
+                ChartBackground* m_backgroundItem;
+                QGraphicsSimpleTextItem* m_titleItem;
+                int m_marginBig;
+                int m_marginSmall;
+                int m_marginTiny;
+                QRect m_chartMargins;
+                QRect m_legendMargins;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

src/charttheme.cpp 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$
             **
             ****************************************************************************/
             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartview.h"
             #include "qlegend.h"
             #include "qchartaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "barchartitem_p.h"
             #include "stackedbarchartitem_p.h"
             #include "percentbarchartitem_p.h"
             #include "linechartitem_p.h"
             #include "areachartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "piechartitem_p.h"
             #include "splinechartitem_p.h"
             //themes
             #include "chartthemesystem_p.h"
             #include "chartthemelight_p.h"
             #include "chartthemebluecerulean_p.h"
             #include "chartthemedark_p.h"
             #include "chartthemebrownsand_p.h"
             #include "chartthemebluencs_p.h"
             #include "chartthemehighcontrast_p.h"
             #include "chartthemeblueicy_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTheme::ChartTheme(QChart::ChartTheme id) :
                 m_masterFont(QFont("arial", 14)),
                 m_labelFont(QFont("arial", 10)),
                 m_titleBrush(QColor(QRgb(0x000000))),
                 m_axisLinePen(QPen(QRgb(0x000000))),
                 m_axisLabelBrush(QColor(QRgb(0x000000))),
                 m_backgroundShadesPen(Qt::NoPen),
                 m_backgroundShadesBrush(Qt::NoBrush),
                 m_backgroundShades(BackgroundShadesNone),
                 m_gridLinePen(QPen(QRgb(0x000000)))
             {
                 m_id = id;
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeLight:
                         return new ChartThemeLight();
                     case QChart::ChartThemeBlueCerulean:
                         return new ChartThemeBlueCerulean();
                     case QChart::ChartThemeDark:
                         return new ChartThemeDark();
                     case QChart::ChartThemeBrownSand:
                         return new ChartThemeBrownSand();
                     case QChart::ChartThemeBlueNcs:
                         return new ChartThemeBlueNcs();
                     case QChart::ChartThemeHighContrast:
                         return new ChartThemeHighContrast();
                     case QChart::ChartThemeBlueIcy:
                         return new ChartThemeBlueIcy();
                     default:
                         return new ChartThemeSystem();
                 }
             }
             void ChartTheme::decorate(QChart* chart,bool force)
             {
                 QBrush brush;
                 if(brush == chart->backgroundBrush() || force)
                     chart->setBackgroundBrush(m_chartBackgroundGradient);
                 chart->setTitleFont(m_masterFont);
                 chart->setTitleBrush(m_titleBrush);
             }
             void ChartTheme::decorate(QLegend* legend,bool force)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == legend->pen() || force){
                     legend->setPen(Qt::NoPen);
                 }
                 if (brush == legend->brush() || force) {
                     legend->setBrush(m_chartBackgroundGradient);
                 }
             }
             void ChartTheme::decorate(QAreaSeries* series, int index,bool force)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() || force){
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() || force) {
                    QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                    series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QLineSeries* series,int index,bool force)
             {
                 QPen pen;
                 if(pen == series->pen() || force ){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QBarSeries* series, int index, bool force)
             {
                 QBrush brush;
                 QPen pen;
                 QList<QBarSet*> sets = series->barSets();
                 qreal takeAtPos = 0.5;
                 qreal step = 0.2;
                 if (sets.count() > 1 ) {
                     step = 1.0 / (qreal) sets.count();
                     if (sets.count() % m_seriesGradients.count())
                         step *= m_seriesGradients.count();
                     else
                         step *= (m_seriesGradients.count() - 1);
                 }
                 for (int i(0); i < sets.count(); i++) {
                     int colorIndex = (index + i) % m_seriesGradients.count();
                     if (i > 0 && i % m_seriesGradients.count() == 0) {
                         // There is no dedicated base color for each sets, generate more colors
                         takeAtPos += step;
                         if (takeAtPos == 1.0)
                             takeAtPos += step;
                         takeAtPos -= (int) takeAtPos;
                     }
-                    qDebug() << "pos:" << takeAtPos;
                     if (brush == sets.at(i)->brush() || force )
                         sets.at(i)->setBrush(colorAt(m_seriesGradients.at(colorIndex), takeAtPos));
                     // Pick label color from the opposite end of the gradient.
                     // 0.3 as a boundary seems to work well.
                     if (takeAtPos < 0.3)
                         sets.at(i)->setLabelBrush(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1));
                     else
                         sets.at(i)->setLabelBrush(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0));
                     if (pen == sets.at(i)->pen() || force) {
                         QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                         sets.at(i)->setPen(c);
                     }
                 }
             }
             void ChartTheme::decorate(QScatterSeries* series, int index,bool force)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() || force) {
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() || force) {
                     QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                     series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QPieSeries* series, int index, bool force)
             {
                 for (int i(0); i < series->slices().count(); i++) {
                     QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                     // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                     qreal pos = (qreal) (i + 1) / (qreal) series->count();
                     QColor brushColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     QPieSlice *s = series->slices().at(i);
                     PieSliceData data = PieSliceData::data(s);
                     if (data.m_slicePen.isThemed() || force) {
                         data.m_slicePen = penColor;
                         data.m_slicePen.setThemed(true);
                     }
                     if (data.m_sliceBrush.isThemed() || force) {
                         data.m_sliceBrush = brushColor;
                         data.m_sliceBrush.setThemed(true);
                     }
                     if (data.m_labelPen.isThemed() || force) {
                         data.m_labelPen = QPen(m_titleBrush.color());
                         data.m_labelPen.setThemed(true);
                     }
                     if (data.m_labelFont.isThemed() || force) {
                         data.m_labelFont = m_labelFont;
                         data.m_labelFont.setThemed(true);
                     }
                     if (PieSliceData::data(s) != data) {
                         PieSliceData::data(s) = data;
                         emit PieSliceData::data(s).emitChangedSignal(s);
                     }
                 }
             }
             void ChartTheme::decorate(QSplineSeries* series, int index, bool force)
             {
                 QPen pen;
                 if(pen == series->pen() || force){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QChartAxis* axis,bool axisX, bool force)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 if (axis->isAxisVisible()) {
                     if(brush == axis->labelsBrush() || force){
                         axis->setLabelsBrush(m_axisLabelBrush);
                     }
                     if(pen == axis->labelsPen() || force){
                         axis->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
                     }
                    if (axis->shadesVisible() || force) {
                      if(brush == axis->shadesBrush() || force){
                          axis->setShadesBrush(m_backgroundShadesBrush);
                      }
                      if(pen == axis->shadesPen() || force){
                          axis->setShadesPen(m_backgroundShadesPen);
                      }
                      if(force && (m_backgroundShades == BackgroundShadesBoth
                                      || (m_backgroundShades == BackgroundShadesVertical && axisX)
                                      || (m_backgroundShades == BackgroundShadesHorizontal && !axisX))){
                          axis->setShadesVisible(true);
                      }
                    }
                     if(pen == axis->axisPen() || force){
                         axis->setAxisPen(m_axisLinePen);
                     }
                     if(pen == axis->gridLinePen() || force){
                         axis->setGridLinePen(m_gridLinePen);
                     }
                     if(font == axis->labelsFont() || force){
                         axis->setLabelsFont(m_labelFont);
                     }
                 }
             }
             void ChartTheme::generateSeriesGradients()
             {
                 // Generate gradients in HSV color space
                 foreach (QColor color, m_seriesColors) {
                     QLinearGradient g;
                     qreal h = color.hsvHueF();
                     qreal s = color.hsvSaturationF();
                     // TODO: tune the algorithm to give nice results with most base colors defined in
                     // most themes. The rest of the gradients we can define manually in theme specific
                     // implementation.
                     QColor start = color;
                     start.setHsvF(h, 0.0, 1.0);
                     g.setColorAt(0.0, start);
                     g.setColorAt(0.5, color);
                     QColor end = color;
                     end.setHsvF(h, s, 0.25);
                     g.setColorAt(1.0, end);
                     m_seriesGradients << g;
                 }
             }
             QColor ChartTheme::colorAt(const QColor &start, const QColor &end, qreal pos)
             {
                 Q_ASSERT(pos >=0.0 && pos <= 1.0);
                 qreal r = start.redF() + ((end.redF() - start.redF()) * pos);
                 qreal g = start.greenF() + ((end.greenF() - start.greenF()) * pos);
                 qreal b = start.blueF() + ((end.blueF() - start.blueF()) * pos);
                 QColor c;
                 c.setRgbF(r, g, b);
                 return c;
             }
             QColor ChartTheme::colorAt(const QGradient &gradient, qreal pos)
             {
                 Q_ASSERT(pos >=0 && pos <= 1.0);
                 // another possibility:
                 // http://stackoverflow.com/questions/3306786/get-intermediate-color-from-a-gradient
                 QGradientStops stops = gradient.stops();
                 int count = stops.count();
                 // find previous stop relative to position
                 QGradientStop prev = stops.first();
                 for (int i=0; i<count; i++) {
                     QGradientStop stop = stops.at(i);
                     if (pos > stop.first)
                         prev = stop;
                     // given position is actually a stop position?
                     if (pos == stop.first) {
                         //qDebug() << "stop color" << pos;
                         return stop.second;
                     }
                 }
                 // find next stop relative to position
                 QGradientStop next = stops.last();
                 for (int i=count-1; i>=0; i--) {
                     QGradientStop stop = stops.at(i);
                     if (pos < stop.first)
                         next = stop;
                 }
                 //qDebug() << "prev" << prev.first << "pos" << pos << "next" << next.first;
                 qreal range = next.first - prev.first;
                 qreal posDelta = pos - prev.first;
                 qreal relativePos = posDelta / range;
                 //qDebug() << "range" << range << "posDelta" << posDelta << "relativePos" << relativePos;
                 return colorAt(prev.second, next.second, relativePos);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/legendmarker.cpp +122 -144

@@ -1,214 +1,192
1	/****************************************************************************	1	/****************************************************************************
2	**	2	**
3	** Copyright (C) 2012 Digia Plc	3	** Copyright (C) 2012 Digia Plc
4	** All rights reserved.	4	** All rights reserved.
5	** For any questions to Digia, please use contact form at http://qt.digia.com	5	** For any questions to Digia, please use contact form at http://qt.digia.com
6	**	6	**
7	** This file is part of the Qt Commercial Charts Add-on.	7	** This file is part of the Qt Commercial Charts Add-on.
8	**	8	**
9	** $QT_BEGIN_LICENSE$	9	** $QT_BEGIN_LICENSE$
10	** Licensees holding valid Qt Commercial licenses may use this file in	10	** Licensees holding valid Qt Commercial licenses may use this file in
11	** accordance with the Qt Commercial License Agreement provided with the	11	** accordance with the Qt Commercial License Agreement provided with the
12	** Software or, alternatively, in accordance with the terms contained in	12	** Software or, alternatively, in accordance with the terms contained in
13	** a written agreement between you and Digia.	13	** a written agreement between you and Digia.
14	**	14	**
15	** If you have questions regarding the use of this file, please use	15	** If you have questions regarding the use of this file, please use
16	** contact form at http://qt.digia.com	16	** contact form at http://qt.digia.com
17	** $QT_END_LICENSE$	17	** $QT_END_LICENSE$
18	**	18	**
19	****************************************************************************/	19	****************************************************************************/
20		20
21	#include "qchartglobal.h"
22	#include "legendmarker_p.h"	21	#include "legendmarker_p.h"
		22	#include "qlegend.h"
		23	#include "qbarseries.h"
		24	#include "qpieseries.h"
23	#include <qpieslice.h>	25	#include <qpieslice.h>
24	#include <qbarset.h>	26	#include <qbarset.h>
25	#include <qxyseries.h>	27	#include <qxyseries.h>
26	#include <qareaseries.h>	28	#include <qareaseries.h>
27	#include <QPainter>	29	#include <QPainter>
28	#include <QGraphicsSceneEvent>	30	#include <QGraphicsSceneEvent>
29	#include <QGraphicsSimpleTextItem>	31	#include <QGraphicsSimpleTextItem>
30		32
31	QTCOMMERCIALCHART_BEGIN_NAMESPACE	33	QTCOMMERCIALCHART_BEGIN_NAMESPACE
32		34
33	LegendMarker::LegendMarker(QSeries ~~series~~, ~~QGraphicsItem~~ ~~parent~~) : QGraphicsObject(~~parent~~),	35	LegendMarker::LegendMarker(QSeries* series,QLegend *legend) : QGraphicsObject(legend),
34	m_pos(0,0),	36	m_series(series),
35	m_size(0,0),	37	m_markerRect(0,0,10.0,10.0),
36	m_boundingRect(0,0,0,0),	38	m_boundingRect(0,0,0,0),
37	m_markerBoundingRect(0,0,0,0),	39	m_legend(legend),
38	m_series(series),	40	m_textItem(new QGraphicsSimpleTextItem(this)),
39	m_barset(0),	41	m_rectItem(new QGraphicsRectItem(this))
40	m_pieslice(0),
41	m_textItem(new QGraphicsSimpleTextItem(this))
42	{
43	setAcceptedMouseButtons(Qt::LeftButton\|Qt::RightButton);
44	}
45
46	LegendMarker::LegendMarker(QSeries series, QBarSet barset, QGraphicsItem *parent) : QGraphicsObject(parent),
47	m_pos(0,0),
48	m_size(0,0),
49	m_boundingRect(0,0,0,0),
50	m_markerBoundingRect(0,0,0,0),
51	m_series(series),
52	m_barset(barset),
53	m_pieslice(0),
54	m_textItem(new QGraphicsSimpleTextItem(this))
55	{	42	{
56	setAcceptedMouseButtons(Qt::LeftButton\|Qt::RightButton);	43	//setAcceptedMouseButtons(Qt::LeftButton\|Qt::RightButton);
57	}	44	m_rectItem->setRect(m_markerRect);
58		45	updateLayout();
59	LegendMarker::LegendMarker(QSeries series, QPieSlice pieslice, QGraphicsItem *parent) : QGraphicsObject(parent),
60	m_pos(0,0),
61	m_size(0,0),
62	m_boundingRect(0,0,0,0),
63	m_markerBoundingRect(0,0,0,0),
64	m_series(series),
65	m_barset(0),
66	m_pieslice(pieslice),
67	m_textItem(new QGraphicsSimpleTextItem(this))
68	{
69	setAcceptedMouseButtons(Qt::LeftButton\|Qt::RightButton);
70	}
71
72	void LegendMarker::setPos(qreal x, qreal y)
73	{
74	m_pos = QPointF(x,y);
75	layoutChanged();
76	}	46	}
77		47
78	void LegendMarker::setPen(const QPen &pen)	48	void LegendMarker::setPen(const QPen &pen)
79	{	49	{
80	m_pen = pen;	50	m_textItem->setPen(pen);
		51	updateLayout();
81	}	52	}
82		53
83	QPen LegendMarker::pen() const	54	QPen LegendMarker::pen() const
84	{	55	{
85	return m_pen;	56	return m_textItem->pen();
86	}	57	}
87		58
88	void LegendMarker::setBrush(const QBrush &brush)	59	void LegendMarker::setBrush(const QBrush &brush)
89	{	60	{
90	m_brush = brush;	61	m_rectItem->setBrush(brush);
91	}	62	}
92		63
93	QBrush LegendMarker::brush() const	64	QBrush LegendMarker::brush() const
94	{	65	{
95	return m_brush;	66	return m_rectItem->brush();
96	}	67	}
97		68
98	void LegendMarker::set~~Name~~(const QString name)	69	void LegendMarker::setLabel(const QString name)
99	{	70	{
100	m_textItem->setText(name);	71	m_textItem->setText(name);
101	~~layoutChanged~~();	72	updateLayout();
102	}	73	}
103		74
104	QString LegendMarker::name() const	75	void LegendMarker::setSize(const QSize& size)
105	{	76	{
106	return m_textItem->text();	77	m_markerRect = QRectF(0,0,size.width(),size.height());
107	}	78	}
108		79
109	QS~~eries~~* LegendMarker::~~series~~() const	80	QString LegendMarker::label() const
110	{	81	{
111	return m_~~series~~;	82	return m_textItem->text();
112	}	83	}
113		84
114	void LegendMarker::paint(QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget)	85	void LegendMarker::paint(QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget)
115	{	86	{
116	Q_UNUSED(option)	87	Q_UNUSED(option)
117	Q_UNUSED(widget)	88	Q_UNUSED(widget)
118		89	Q_UNUSED(painter)
119	painter->setPen(m_pen);
120	painter->setBrush(m_brush);
121	painter->drawRect(m_markerBoundingRect);
122	}	90	}
123		91
124	QRectF LegendMarker::boundingRect() const	92	QRectF LegendMarker::boundingRect() const
125	{	93	{
126	return m_boundingRect;	94	return m_boundingRect;
127	}	95	}
128		96
129	void LegendMarker::~~layoutChanged~~()	97	void LegendMarker::updateLayout()
130	{	98	{
131	QSizeF markerSize(10,10);
132	qreal margin = 2;
133
134	m_size.setHeight(markerSize.height() + 2 * margin);
135	m_size.setWidth(m_textItem->boundingRect().width() + markerSize.width() + 3 * margin);
136		99
137	m_boundingRect = QRectF(m_pos.x(),m_pos.y(),m_size.width(),m_size.height());	100	static const qreal margin = 2;
		101	static const qreal space = 4;
138		102
139	m_markerBoundingRect = QRectF(m_pos.x() + margin, m_pos.y() + margin, markerSize.width(),markerSize.height());	103	const QRectF& textRect = m_textItem->boundingRect();
		104	prepareGeometryChange();
		105	m_boundingRect = QRectF(0,0,m_markerRect.width() + 2margin + space + textRect.width(),qMax(m_markerRect.height()+2margin,textRect.height()+2*margin));
		106	m_textItem->setPos(m_markerRect.width() + space + margin,m_boundingRect.height()/2 - textRect.height()/2);
		107	m_rectItem->setPos(margin,m_boundingRect.height()/2 - m_markerRect.height()/2);
140		108
141	m_textItem->setPos(m_pos.x() + markerSize.width() + 2 * margin, m_pos.y() + margin);
142	}	109	}
143		110
144	void LegendMarker::mousePressEvent(QGraphicsSceneMouseEvent *event)	111	void LegendMarker::mousePressEvent(QGraphicsSceneMouseEvent *event)
145	{	112	{
146	switch (m_series->type()) {	113	QGraphicsObject::mousePressEvent(event);
147	case QSeries::SeriesTypeLine:	114	emit selected();
148	case QSeries::SeriesTypeArea:
149	case QSeries::SeriesTypeScatter:
150	case QSeries::SeriesTypeSpline: {
151	emit clicked(m_series,event->button());
152	break;
153	}
154	case QSeries::SeriesTypeBar:
155	case QSeries::SeriesTypeStackedBar:
156	case QSeries::SeriesTypePercentBar: {
157	emit clicked(m_barset,event->button());
158	break;
159	}
160	case QSeries::SeriesTypePie: {
161	emit clicked(m_pieslice,event->button());
162	break;
163	}
164	default: {
165	break;
166	}
167	}
168	}	115	}
169		116
170	void LegendMarker::changed()	117	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		118
		119	AreaLegendMarker::AreaLegendMarker(QAreaSeries series,QLegend legend) : LegendMarker(series,legend),
		120	m_series(series)
171	{	121	{
172	setPen(Qt::NoPen);	122	QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
173	switch (m_series->type()) {	123	QObject::connect(series,SIGNAL(updated()), this, SLOT(updated()));
174	case QSeries::SeriesTypeArea: {	124	updated();
175	QAreaSeries* s = static_cast<QAreaSeries*> (m_series);	125	}
176	setBrush(s->brush());	126
177	setName(s->name());	127	void AreaLegendMarker::updated()
178	break;	128	{
179	}	129	setBrush(m_series->brush());
180	case QSeries::SeriesTypeLine:	130	setLabel(m_series->name());
181	case QSeries::SeriesTypeSpline: {	131	}
182	QXYSeries* s = static_cast<QXYSeries*> (m_series);	132
183	setBrush(QBrush(s->pen().color(),Qt::SolidPattern));	133	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
184	setName(s->name());	134
185	break;	135	BarLegendMarker::BarLegendMarker(QBarSeries series,QBarSet barset, QLegend *legend) : LegendMarker(series,legend),
186	}	136	m_barset(barset)
187	case QSeries::SeriesTypeScatter: {	137	{
188	QXYSeries* s = static_cast<QXYSeries*> (m_series);	138	QObject::connect(this, SIGNAL(selected()),series, SIGNAL(selected()));
189	setBrush(s->brush());	139	QObject::connect(barset, SIGNAL(valueChanged()), this, SLOT(updated()));
190	setName(s->name());	140	updated();
191	break;	141	}
		142
		143	void BarLegendMarker::updated()
		144	{
		145	setBrush(m_barset->brush());
		146	setLabel(m_barset->name());
		147	}
		148
		149	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		150
		151	PieLegendMarker::PieLegendMarker(QPieSeries* series,QPieSlice pieslice, QLegend legend) : LegendMarker(series,legend),
		152	m_pieslice(pieslice)
		153	{
		154	QObject::connect(this, SIGNAL(selected()),pieslice, SIGNAL(selected()));
		155	QObject::connect(pieslice, SIGNAL(changed()), this, SLOT(updated()));
		156	QObject::connect(pieslice, SIGNAL(destroyed()), this, SLOT(deleteLater())); //TODO:checkthis
		157	updated();
		158	}
		159
		160	void PieLegendMarker::updated()
		161	{
		162	setBrush(m_pieslice->brush());
		163	setLabel(m_pieslice->label());
		164	}
		165
		166	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		167
		168	XYLegendMarker::XYLegendMarker(QXYSeries series, QLegend legend) : LegendMarker(series,legend),
		169	m_series(series)
		170	{
		171	QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
		172	QObject::connect(series,SIGNAL(updated()), this, SLOT(updated()));
		173	updated();
		174	}
		175
		176	void XYLegendMarker::updated()
		177	{
		178	setLabel(m_series->name());
		179
		180	if(m_series->type()== QSeries::SeriesTypeScatter)
		181	{
		182	setBrush(m_series->brush());
		183
192	}	184	}
193	case QSeries::SeriesTypeBar:	185	else {
194	case QSeries::SeriesTypeStackedBar:	186	setBrush(QBrush(m_series->pen().color()));
195	case QSeries::SeriesTypePercentBar: {
196	setBrush(m_barset->brush());
197	setName(m_barset->name());
198	break;
199	}
200	case QSeries::SeriesTypePie: {
201	setBrush(m_pieslice->brush());
202	setName(m_pieslice->label());
203	break;
204	}
205	default: {
206	setBrush(Qt::NoBrush);
207	break;
208	}
209	}	187	}
210	}	188	}
211		189
212	#include "moc_legendmarker_p.cpp"	190	#include "moc_legendmarker_p.cpp"
213		191
214	QTCOMMERCIALCHART_END_NAMESPACE	192	QTCOMMERCIALCHART_END_NAMESPACE

src/legendmarker_p.h +60 -26

             /****************************************************************************
             **
             ** 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 LEGENDMARKER_P_H
             #define LEGENDMARKER_P_H
             #include "qchartglobal.h"
             #include <QGraphicsObject>
             #include <QBrush>
             #include <QPen>
             #include <QGraphicsSimpleTextItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QSeries;
+            class QAreaSeries;
+            class QXYSeries;
             class QBarSet;
+            class QBarSeries;
             class QPieSlice;
+            class QLegend;
+            class QPieSeries;
-            // TODO: split this to 3 different markers for series, barset and pieslice. Current implementation is easier to misuse...
             class LegendMarker : public QGraphicsObject
             {
                 Q_OBJECT
             public:
-                LegendMarker(QSeries *series, QGraphicsItem *parent = 0);
+                explicit LegendMarker(QSeries* m_series,QLegend *parent);
-                LegendMarker(QSeries *series, QBarSet *barset, QGraphicsItem *parent = 0);
-                LegendMarker(QSeries *series, QPieSlice *pieslice, QGraphicsItem *parent = 0);
-                void setPos(qreal x, qreal y);
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
-                void setName(const QString name);
+                void setSize(const QSize& size);
-                QString name() const;
-                QSeries* series() const;
+                void setLabel(const QString label);
+                QString label() const;
+                QSeries* series() const { return m_series;}
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
-                void layoutChanged();
+                void updateLayout();
-            public:
+            protected:
                 // From QGraphicsObject
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             Q_SIGNALS:
-                void clicked(QSeries *series, Qt::MouseButton button);
+                void selected();
-                void clicked(QBarSet *barset, Qt::MouseButton button);
-                void clicked(QPieSlice *pieslice, Qt::MouseButton button);
             public Q_SLOTS:
-                void changed();
+                virtual void updated() = 0;
-            private:
+            protected:
-                QPointF m_pos;
+                QSeries* m_series;
-                QSize m_size;
+                QRectF m_markerRect;
                 QRectF m_boundingRect;
-                QRectF m_markerBoundingRect;
+                QLegend* m_legend;
-                QBrush m_brush;
+                QGraphicsSimpleTextItem *m_textItem;
-                QPen m_pen;
+                QGraphicsRectItem *m_rectItem;
-                QSeries *m_series;
+            };
+            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            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 *barseires, 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;
-                QGraphicsSimpleTextItem *m_textItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // LEGENDMARKER_P_H

src/legendscrollbutton.cpp +1 -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 "legendscrollbutton_p.h"
             #include "qlegend.h"
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendScrollButton::LegendScrollButton(ScrollButtonId id, QLegend *legend)
                 : QGraphicsPolygonItem(legend),
                 m_id(id),
                 m_ledgend(legend)
             {
                 setAcceptedMouseButtons(Qt::LeftButton);
             }
             LegendScrollButton::ScrollButtonId LegendScrollButton::id()
             {
                 return m_id;
             }
             void LegendScrollButton::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 Q_UNUSED(event);
-                m_ledgend->scrollButtonClicked(this);
+                //m_ledgend->scrollButtonClicked(this);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieslice.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$
             **
             ****************************************************************************/
             #ifndef QPIESLICE_H
             #define QPIESLICE_H
             #include <qchartglobal.h>
             #include <QObject>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieSliceData;
             class QTCOMMERCIALCHART_EXPORT QPieSlice : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString label READ label WRITE setLabel NOTIFY changed)
                 Q_PROPERTY(qreal value READ value WRITE setValue NOTIFY changed)
             public:
                 QPieSlice(QObject *parent = 0);
                 QPieSlice(qreal value, QString label, QObject *parent = 0);
                 virtual ~QPieSlice();
                 // data
                 void setValue(qreal value);
                 qreal value() const;
                 void setLabel(QString label);
                 QString label() const;
                 void setLabelVisible(bool visible = true);
                 bool isLabelVisible() const;
                 void setExploded(bool exploded = true);
                 bool isExploded() const;
                 // generated data
                 qreal percentage() const;
                 qreal startAngle() const;
                 qreal endAngle() const;
                 // customization
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setLabelPen(const QPen &pen);
                 QPen labelPen() const;
                 void setLabelFont(const QFont &font);
                 QFont labelFont() const;
                 void setLabelArmLengthFactor(qreal factor);
                 qreal labelArmLengthFactor() const;
                 void setExplodeDistanceFactor(qreal factor);
                 qreal explodeDistanceFactor() const;
             Q_SIGNALS:
                 void clicked(Qt::MouseButtons buttons);
                 void hoverEnter();
                 void hoverLeave();
                 void changed();
+                void selected();
             private:
                 friend class PieSliceData;
                 PieSliceData * const d;
                 Q_DISABLE_COPY(QPieSlice)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESLICE_H

src/qchart.cpp +39 -188

             /****************************************************************************
             **
             ** 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 <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             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
              \value ChartThemeCount Not really a theme; the total count of themes.
              */
             /*!
              \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 QChartSeries and other chart related objects like
              QChartAxis and QChartLegend. If you simply want to show a chart in a layout, you can use the
              convenience class QChartView instead of QChart.
              \sa QChartView
              */
             /*!
              Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
-            d_ptr(new QChartPrivate(this))
+            d_ptr(new QChartPrivate())
             {
-                //setMinimumSize(200,200);
                 d_ptr->m_legend = new QLegend(this);
                 d_ptr->m_dataset = new ChartDataSet(this);
                 d_ptr->m_presenter = new ChartPresenter(this,d_ptr->m_dataset);
-                setMinimumSize(d_ptr->m_padding.left() * 3, d_ptr->m_padding.top() * 3);
+                d_ptr->m_presenter->setTheme(QChart::ChartThemeDefault,false);
+                //TODO:fix me setMinimumSize(d_ptr->m_padding.left() * 3, d_ptr->m_padding.top() * 3);
                 connect(d_ptr->m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),d_ptr->m_legend,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 connect(d_ptr->m_dataset,SIGNAL(seriesRemoved(QSeries*)),d_ptr->m_legend,SLOT(handleSeriesRemoved(QSeries*)));
             }
             /*!
              Destroys the object and it's children, like QChartSeries and QChartAxis object added to it.
              */
             QChart::~QChart()
             {
                 //delete first presenter , since this is a root of all the graphical items
                 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).
              */
             void QChart::addSeries(QSeries* series, QChartAxis* axisY)
             {
                 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(QSeries* 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)
             {
-                d_ptr->createChartBackgroundItem();
+                d_ptr->m_presenter->createChartBackgroundItem();
-                d_ptr->m_backgroundItem->setBrush(brush);
+                d_ptr->m_presenter->m_backgroundItem->setBrush(brush);
-                d_ptr->m_backgroundItem->update();
+                d_ptr->m_presenter->m_backgroundItem->update();
             }
             QBrush QChart::backgroundBrush() const
             {
-                if (!d_ptr->m_backgroundItem) return QBrush();
+                if (!d_ptr->m_presenter->m_backgroundItem) return QBrush();
-                return (d_ptr->m_backgroundItem)->brush();
+                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)
             {
-                d_ptr->createChartBackgroundItem();
+                d_ptr->m_presenter->createChartBackgroundItem();
-                d_ptr->m_backgroundItem->setPen(pen);
+                d_ptr->m_presenter->m_backgroundItem->setPen(pen);
-                d_ptr->m_backgroundItem->update();
+                d_ptr->m_presenter->m_backgroundItem->update();
             }
             QPen QChart::backgroundPen() const
             {
-                if (!d_ptr->m_backgroundItem) return QPen();
+                if (!d_ptr->m_presenter->m_backgroundItem) return QPen();
-                return d_ptr->m_backgroundItem->pen();
+                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)
             {
-                d_ptr->createChartTitleItem();
+                d_ptr->m_presenter->createChartTitleItem();
-                d_ptr->m_titleItem->setText(title);
+                d_ptr->m_presenter->m_titleItem->setText(title);
-                d_ptr->updateLayout();
+                d_ptr->m_presenter->updateLayout();
             }
             /*!
              Returns the chart title. The description text that is drawn above the chart.
              */
             QString QChart::title() const
             {
-                if (d_ptr->m_titleItem)
+                if (d_ptr->m_presenter->m_titleItem)
-                return d_ptr->m_titleItem->text();
+                return d_ptr->m_presenter->m_titleItem->text();
                 else
                 return QString();
             }
             /*!
              Sets the \a font that is used for rendering the description text that is rendered above the chart.
              */
             void QChart::setTitleFont(const QFont& font)
             {
-                d_ptr->createChartTitleItem();
+                d_ptr->m_presenter->createChartTitleItem();
-                d_ptr->m_titleItem->setFont(font);
+                d_ptr->m_presenter->m_titleItem->setFont(font);
-                d_ptr->updateLayout();
+                d_ptr->m_presenter->updateLayout();
             }
             /*!
              Sets the \a brush used for rendering the title text.
              */
             void QChart::setTitleBrush(const QBrush &brush)
             {
-                d_ptr->createChartTitleItem();
+                d_ptr->m_presenter->createChartTitleItem();
-                d_ptr->m_titleItem->setBrush(brush);
+                d_ptr->m_presenter->m_titleItem->setBrush(brush);
-                d_ptr->updateLayout();
+                d_ptr->m_presenter->updateLayout();
             }
             /*!
              Returns the brush used for rendering the title text.
              */
             QBrush QChart::titleBrush() const
             {
-                if (!d_ptr->m_titleItem) return QBrush();
+                if (!d_ptr->m_presenter->m_titleItem) return QBrush();
-                return d_ptr->m_titleItem->brush();
+                return d_ptr->m_presenter->m_titleItem->brush();
             }
             /*!
              Sets the \a theme used by the chart for rendering the graphical representation of the data
              \sa ChartTheme, chartTheme()
              */
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 d_ptr->m_presenter->setTheme(theme);
             }
             /*!
              Returns the theme enum used by the chart.
              \sa ChartTheme, setChartTheme()
              */
             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();
             }
             /*!
              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();
             }
             /*!
              Returns the pointer to the x axis object of the chart
              */
             QChartAxis* QChart::axisX() const
             {
                 return d_ptr->m_dataset->axisX();
             }
             /*!
              Returns the pointer to the y axis object of the chart
              */
             QChartAxis* QChart::axisY() const
             {
                 return d_ptr->m_dataset->axisY();
             }
             /*!
              Returns the legend object of the chart. Ownership stays in chart.
              */
             QLegend* QChart::legend() const
             {
                 return d_ptr->m_legend;
             }
-            QRect QChart::padding() const
+            QRect QChart::margins() const
             {
-                return d_ptr->m_padding;
+                return d_ptr->m_presenter->margins();
             }
             /*!
              Resizes and updates the chart area using the \a event data
              */
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 d_ptr->m_rect = QRectF(QPoint(0,0),event->newSize());
-                d_ptr->updateLayout();
                 QGraphicsWidget::resizeEvent(event);
-                update();
+                d_ptr->m_presenter->setGeometry(d_ptr->m_rect);
             }
             /*!
              Sets animation \a options for the chart
              */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 d_ptr->m_presenter->setAnimationOptions(options);
             }
             /*!
              Returns animation options for the chart
              */
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return d_ptr->m_presenter->animationOptions();
             }
             void QChart::scrollLeft()
             {
-                d_ptr->m_presenter->scroll(-d_ptr->m_presenter->geometry().width()/(axisX()->ticksCount()-1),0);
+                d_ptr->m_presenter->scroll(-d_ptr->m_presenter->chartGeometry().width()/(axisX()->ticksCount()-1),0);
             }
             void QChart::scrollRight()
             {
-                d_ptr->m_presenter->scroll(d_ptr->m_presenter->geometry().width()/(axisX()->ticksCount()-1),0);
+                d_ptr->m_presenter->scroll(d_ptr->m_presenter->chartGeometry().width()/(axisX()->ticksCount()-1),0);
             }
             void QChart::scrollUp()
             {
-                d_ptr->m_presenter->scroll(0,d_ptr->m_presenter->geometry().width()/(axisY()->ticksCount()-1));
+                d_ptr->m_presenter->scroll(0,d_ptr->m_presenter->chartGeometry().width()/(axisY()->ticksCount()-1));
             }
             void QChart::scrollDown()
             {
-                d_ptr->m_presenter->scroll(0,-d_ptr->m_presenter->geometry().width()/(axisY()->ticksCount()-1));
+                d_ptr->m_presenter->scroll(0,-d_ptr->m_presenter->chartGeometry().width()/(axisY()->ticksCount()-1));
             }
             void QChart::setBackgroundVisible(bool visible)
             {
-                d_ptr->createChartBackgroundItem();
+                d_ptr->m_presenter->createChartBackgroundItem();
-                d_ptr->m_backgroundItem->setVisible(visible);
+                d_ptr->m_presenter->m_backgroundItem->setVisible(visible);
             }
             bool QChart::isBackgroundVisible() const
             {
-                if (!d_ptr->m_backgroundItem) return false;
+                if (!d_ptr->m_presenter->m_backgroundItem) return false;
-                return d_ptr->m_backgroundItem->isVisible();
+                return d_ptr->m_presenter->m_backgroundItem->isVisible();
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QChartPrivate::QChartPrivate(QChart *parent):
+            QChartPrivate::QChartPrivate():
-            q_ptr(parent),
-            m_backgroundItem(0),
-            m_titleItem(0),
             m_legend(0),
             m_dataset(0),
-            m_presenter(0),
+            m_presenter(0)
-            m_padding(QRect(50,50,0,0))
             {
             }
             QChartPrivate::~QChartPrivate()
             {
             }
-            void QChartPrivate::createChartBackgroundItem()
-                if (!m_backgroundItem) {
-                    m_backgroundItem = new ChartBackground(q_ptr);
-                    m_backgroundItem->setPen(Qt::NoPen);
-                    m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
-            void QChartPrivate::createChartTitleItem()
-                if (!m_titleItem) {
-                    m_titleItem = new QGraphicsSimpleTextItem(q_ptr);
-                    m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
-            void QChartPrivate::updateLegendLayout()
-                //int legendPadding = m_chart->legend()->padding();
-                int legendPadding = 30;
-                QRectF rect = m_rect;
-                if ((m_legend->attachedToChart()) && (m_legend->isVisible())) {
-                    // Reserve some space for legend
-                    switch (m_legend->alignment()) {
-                    case QLegend::AlignmentTop: {
-                        rect.adjust(m_padding.left(),
-                                    m_padding.top() + legendPadding,
-                                    -m_padding.right(),
-                                    -m_padding.bottom());
-                        break;
-                    case QLegend::AlignmentBottom: {
-                        rect.adjust(m_padding.left(),
-                                    m_padding.top(),
-                                    -m_padding.right(),
-                                    -m_padding.bottom() - legendPadding);
-                        break;
-                    case QLegend::AlignmentLeft: {
-                        rect.adjust(m_padding.left() + legendPadding,
-                                    m_padding.top(),
-                                    -m_padding.right(),
-                                    -m_padding.bottom());
-                        break;
-                    case QLegend::AlignmentRight: {
-                        rect.adjust(m_padding.left(),
-                                    m_padding.top(),
-                                    -m_padding.right() - legendPadding,
-                                    -m_padding.bottom());
-                        break;
-                    default: {
-                        rect.adjust(m_padding.left(),
-                                    m_padding.top(),
-                                    -m_padding.right(),
-                                    -m_padding.bottom());
-                        break;
-                } else {
-                    rect.adjust(m_padding.left(),
-                                m_padding.top(),
-                                -m_padding.right(),
-                                -m_padding.bottom());
-                QRectF plotRect = m_rect.adjusted(m_padding.left()
-                                                  ,m_padding.top()
-                                                  ,-m_padding.right()
-                                                  ,-m_padding.bottom());
-                QRectF legendRect;
-                int padding = 0; // TODO: fix this
-                switch (m_legend->alignment())
-                    case QLegend::AlignmentTop: {
-                        legendRect = m_rect.adjusted(0,padding,0,-padding - plotRect.height());
-                        break;
-                    case QLegend::AlignmentBottom: {
-                        legendRect = m_rect.adjusted(padding,padding + plotRect.height(),-padding,0);
-                        break;
-                    case QLegend::AlignmentLeft: {
-                        legendRect = m_rect.adjusted(0,padding,-padding - plotRect.width(),-padding);
-                        break;
-                    case QLegend::AlignmentRight: {
-                        legendRect = m_rect.adjusted(padding + plotRect.width(),padding,0,-padding);
-                        break;
-                    default: {
-                        legendRect = plotRect;
-                        break;
-                m_legend->setMaximumSize(legendRect.size());
-                qreal width = legendRect.width() - m_legend->size().width();
-                qreal height = legendRect.height() - m_legend->size().height();
-                QPointF pos = legendRect.topLeft();
-                if (width > 0) {
-                    pos.setX(pos.x() + width/2);
-                if (height > 0) {
-                    pos.setY(pos.y() + height/2);
-                m_legend->setPos(pos);
-            void QChartPrivate::updateLayout()
-                if (!m_rect.isValid()) return;
-                int padding = m_padding.top();
-                int backgroundPadding = m_presenter->backgroundPadding();
-                // recalculate title position
-                if (m_titleItem) {
-                    QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
-                    m_titleItem->setPos(center.x(),m_rect.top()/2 + padding/2);
-                //recalculate background gradient
-                if (m_backgroundItem) {
-                    m_backgroundItem->setRect(m_rect.adjusted(backgroundPadding,backgroundPadding, -backgroundPadding, -backgroundPadding));
-                // recalculate legend position
-                if (m_legend) {
-                    if ((m_legend->attachedToChart()) && (m_legend->parentObject() == q_ptr)) {
-                        updateLegendLayout();
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +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$
             **
             ****************************************************************************/
             #ifndef QCHART_H
             #define QCHART_H
             #include <QSeries>
             #include <QGraphicsWidget>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QSeries;
             class QChartAxis;
             class QLegend;
             struct QChartPrivate;
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
                 Q_ENUMS(ChartTheme)
             public:
                 enum ChartTheme {
                     ChartThemeLight = 0,
                     ChartThemeBlueCerulean,
                     ChartThemeDark,
                     ChartThemeBrownSand,
                     ChartThemeBlueNcs,
                     ChartThemeHighContrast,
                     ChartThemeBlueIcy,
                     ChartThemeCount
                 };
                 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(QSeries *series, QChartAxis *axisY = 0);
                 void removeSeries(QSeries *series);
                 void removeAllSeries();
                 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);
                 bool isBackgroundVisible() const;
                 void setAnimationOptions(AnimationOptions options);
                 AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomIn(const QRectF &rect);
                 void zoomOut();
                 void scrollLeft();
                 void scrollRight();
                 void scrollUp();
                 void scrollDown();
                 QChartAxis* axisX() const;
                 QChartAxis* axisY() const;
                 QLegend* legend() const;
+                QRect margins() const;
-                QRect padding() const;
             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 +2 -13

             /****************************************************************************
             **
             ** 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 "qchartaxis.h"
             #include "qlegend.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
-            #include "chartbackground_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             struct QChartPrivate
             {
-                QChartPrivate(QChart *parent);
+                QChartPrivate();
                 ~QChartPrivate();
-                void createChartBackgroundItem();
-                void createChartTitleItem();
-                void updateLayout();
-                void updateLegendLayout();
-                QChart *q_ptr;
-                ChartBackground* m_backgroundItem;
-                QGraphicsSimpleTextItem* m_titleItem;
                 QRectF m_rect;
                 QLegend* m_legend;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;
-                QRect m_padding;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchartview.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 "qchartview.h"
             #include "qchart_p.h"
             #include "qchartview_p.h"
             #include <QGraphicsScene>
             #include <QRubberBand>
             /*!
                 \enum QChartView::RubberBandPolicy
                 This enum describes the different types of rubber bands that can be used for zoom rect selection
                 \value NoRubberBand
                 \value VerticalRubberBand
                 \value HorizonalRubberBand
                 \value RectangleRubberBand
             */
             /*!
                 \class QChartView
                 \brief Standalone charting widget.
                 QChartView is a standalone widget that can display charts. It does not require separate
                 QGraphicsScene to work. It manages the graphical representation of different types of
                 QChartSeries and other chart related objects like QChartAxis and QChartLegend. If you want to
                 display a chart in your existing QGraphicsScene, you can use the QChart class instead.
                 \sa QChart
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs a chartView object which is a child of a\a parent.
             */
             QChartView::QChartView(QChart *chart,QWidget *parent) :
                 QGraphicsView(parent),
                 d_ptr(new QChartViewPrivate())
             {
                 d_ptr->m_scene = new QGraphicsScene(this);
                 d_ptr->m_chart = chart;
                 setFrameShape(QFrame::NoFrame);
                 setBackgroundRole(QPalette::Window);
                 setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setScene(d_ptr->m_scene);
                 d_ptr->m_scene->addItem(chart);
                 setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
             }
             /*!
                 Destroys the object and it's children, like QChartSeries and QChartAxis object added to it.
             */
             QChartView::~QChartView()
             {
             }
             QChart* QChartView::chart() const
             {
                 return d_ptr->m_chart;
             }
             /*!
                 Sets the RubberBandPlicy to \a policy. Selected policy determines the way zooming is performed.
             */
             void QChartView::setRubberBand(const RubberBands& rubberBand)
             {
                 d_ptr->m_rubberBandFlags=rubberBand;
                 if (!d_ptr->m_rubberBandFlags) {
                     delete d_ptr->m_rubberBand;
                     d_ptr->m_rubberBand=0;
                     return;
                 }
                 if (!d_ptr->m_rubberBand) {
                     d_ptr->m_rubberBand = new QRubberBand(QRubberBand::Rectangle, this);
                     d_ptr->m_rubberBand->setEnabled(true);
                 }
             }
             /*!
                 Returns the RubberBandPolicy that is currently being used by the widget.
             */
             QChartView::RubberBands QChartView::rubberBand() const
             {
                 return d_ptr->m_rubberBandFlags;
             }
             /*!
                 If Left mouse button is pressed and the RubberBandPolicy is enabled the \a event is accepted and the rubber band is displayed on the screen allowing the user to select the zoom area.
                 If different mouse button is pressed and/or the RubberBandPolicy is disabled then the \a event is passed to QGraphicsView::mousePressEvent() implementation.
             */
             void QChartView::mousePressEvent(QMouseEvent *event)
             {
                 if(d_ptr->m_rubberBand && d_ptr->m_rubberBand->isEnabled() && event->button() == Qt::LeftButton) {
-                    int padding = d_ptr->m_chart->padding().top();
+                    int padding = d_ptr->m_chart->margins().top();
                     QRect rect(padding, padding, width() - 2 * padding, height() - 2 * padding);
                     if (rect.contains(event->pos())) {
                         d_ptr->m_rubberBandOrigin = event->pos();
                         d_ptr->m_rubberBand->setGeometry(QRect(d_ptr->m_rubberBandOrigin, QSize()));
                         d_ptr->m_rubberBand->show();
                         event->accept();
                     }
                 }
                 else {
                     QGraphicsView::mousePressEvent(event);
                 }
             }
             /*!
                 If RubberBand rectange specification has been initiated in pressEvent then \a event data is used to update RubberBand geometry.
                 In other case the defualt QGraphicsView::mouseMoveEvent implementation is called.
             */
             void QChartView::mouseMoveEvent(QMouseEvent *event)
             {
                 if(d_ptr->m_rubberBand && d_ptr->m_rubberBand->isVisible()) {
-                    int padding = d_ptr->m_chart->padding().top();
+                    int padding = d_ptr->m_chart->margins().top();
                     QRect rect(padding, padding, width() - 2 * padding, height() - 2 * padding);
                     int width = event->pos().x() - d_ptr->m_rubberBandOrigin.x();
                     int height = event->pos().y() - d_ptr->m_rubberBandOrigin.y();
                     if (!d_ptr->m_rubberBandFlags.testFlag(VerticalRubberBand)) {
                         d_ptr->m_rubberBandOrigin.setY(rect.top());
                         height = rect.height();
                     }
                     if (!d_ptr->m_rubberBandFlags.testFlag(HorizonalRubberBand)) {
                         d_ptr->m_rubberBandOrigin.setX(rect.left());
                         width= rect.width();
                     }
                     d_ptr->m_rubberBand->setGeometry(QRect(d_ptr->m_rubberBandOrigin.x(),d_ptr->m_rubberBandOrigin.y(), width,height).normalized());
                 }
                 else {
                     QGraphicsView::mouseMoveEvent(event);
                 }
             }
             /*!
                 If left mouse button is release and RubberBand is enabled then \a event is accepted and the view is zoomed in to rect specified by RubberBand
                 If it is the right mouse button \a event then RubberBand is dissmissed and zoom is canceled.
             */
             void QChartView::mouseReleaseEvent(QMouseEvent *event)
             {
                 if(d_ptr->m_rubberBand) {
                     if (event->button() == Qt::LeftButton && d_ptr->m_rubberBand->isVisible()) {
                         d_ptr->m_rubberBand->hide();
                         QRect rect = d_ptr->m_rubberBand->geometry();
                         d_ptr->m_chart->zoomIn(rect);
                         event->accept();
                     }
                     if(event->button()==Qt::RightButton){
                         d_ptr->m_chart->zoomOut();
                         event->accept();
                     }
                 }
                 else {
                     QGraphicsView::mouseReleaseEvent(event);
                 }
             }
             /*!
                 Pressing + and - keys performs zoomIn() and zoomOut() respectivly.
                 In other \a event is passed to the QGraphicsView::keyPressEvent() implementation
             */
             void QChartView::keyPressEvent(QKeyEvent *event)
             {
                 switch (event->key()) {
                     case Qt::Key_Plus:
                         d_ptr->m_chart->zoomIn();
                         break;
                     case Qt::Key_Minus:
                         d_ptr->m_chart->zoomOut();
                         break;
                     case Qt::Key_Left:
                         d_ptr->m_chart->scrollLeft();
                         break;
                     case Qt::Key_Right:
                         d_ptr->m_chart->scrollRight();
                         break;
                     case Qt::Key_Up:
                         d_ptr->m_chart->scrollUp();
                         break;
                     case Qt::Key_Down:
                         d_ptr->m_chart->scrollDown();
                         break;
                     default:
                         QGraphicsView::keyPressEvent(event);
                         break;
                 }
             }
             /*!
                 Resizes and updates the chart area using the \a event data
             */
             void QChartView::resizeEvent(QResizeEvent *event)
             {
                 QGraphicsView::resizeEvent(event);
                 d_ptr->m_chart->resize(size());
                 setSceneRect(d_ptr->m_chart->geometry());
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartViewPrivate::QChartViewPrivate():
             m_scene(0),
             m_chart(0),
             m_presenter(0),
             m_rubberBand(0),
             m_rubberBandFlags(QChartView::NoRubberBand)
             {
             }
             QChartViewPrivate::~QChartViewPrivate()
             {
             }
             #include "moc_qchartview.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qlegend.cpp +170 -358

             /****************************************************************************
             **
             ** 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 "qchart_p.h"
             #include "qseries.h"
             #include "legendmarker_p.h"
-            #include "legendscrollbutton_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 "qpieslice.h"
             #include "chartpresenter_p.h"
+            #include "scroller_p.h"
             #include <QPainter>
             #include <QPen>
+            #include <QTimer>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegend
                 \brief part of QtCommercial chart API.
                 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.
                 \mainclass
                 \sa QChart, QSeries
             */
             /*!
                 \enum QLegend::Layout
                 This enum describes the possible position for legend inside chart.
                 \value LayoutTop
                 \value LayoutBottom
                 \value LayoutLeft
                 \value LayoutRight
             */
             /*!
                 \fn void QLegend::clicked(QSeries* series, Qt::MouseButton button)
                 \brief Notifies when series has been clicked on legend \a series \a button
             */
             /*!
                 \fn void QLegend::clicked(QBarSet* barset, Qt::MouseButton button)
                 \brief Notifies when barset has been clicked on legend \a barset \a button
             */
             /*!
                 \fn void QLegend::clicked(QPieSlice* slice, Qt::MouseButton button)
                 \brief Notifies when pie slice has been clicked on legend \a slice \a button
             */
             /*!
                 Constructs the legend object and sets the parent to \a parent
             */
             QLegend::QLegend(QChart *chart):QGraphicsWidget(chart),
                 m_margin(5),
-                m_pos(0,0),
+                m_offsetX(0),
-                m_minimumSize(50,20),                // TODO: magic numbers
+                m_offsetY(0),
-                m_maximumSize(150,100),
-                m_size(m_minimumSize),
                 m_brush(Qt::darkGray),              // TODO: default should come from theme
                 m_alignment(QLegend::AlignmentTop),
-                mFirstMarker(0),
+                m_markers(new QGraphicsItemGroup(this)),
                 m_attachedToChart(true),
-                m_chart(chart)
+                m_chart(chart),
+                m_minWidth(0),
+                m_minHeight(0),
+                m_width(0),
+                m_height(0),
+                m_visible(false),
+                m_dirty(false),
+                m_scroller(new Scroller(this))
             {
-                m_scrollButtonLeft = new LegendScrollButton(LegendScrollButton::ScrollButtonIdLeft, this);
-                m_scrollButtonRight = new LegendScrollButton(LegendScrollButton::ScrollButtonIdRight, this);
-                m_scrollButtonUp = new LegendScrollButton(LegendScrollButton::ScrollButtonIdUp, this);
-                m_scrollButtonDown = new LegendScrollButton(LegendScrollButton::ScrollButtonIdDown, this);
                 setZValue(ChartPresenter::LegendZValue);
+                setFlags(QGraphicsItem::ItemClipsChildrenToShape);
             }
             /*!
                 Paints the legend to given \a painter. Paremeters \a option and \a widget arent used.
             */
             void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
-                Q_UNUSED(option)
+            	Q_UNUSED(option)
-                Q_UNUSED(widget)
+            	Q_UNUSED(widget)
+            	if(!m_visible) return;
                 painter->setOpacity(opacity());
                 painter->setPen(m_pen);
                 painter->setBrush(m_brush);
-            //    painter->drawRect(boundingRect());
+                painter->drawRect(boundingRect());
             }
             /*!
                 Bounding rect of legend.
             */
             QRectF QLegend::boundingRect() const
             {
-                return QRectF(m_pos,m_size);
+                return m_rect;
             }
             /*!
                 Sets the \a brush of legend. Brush affects the background of legend.
             */
             void QLegend::setBrush(const QBrush &brush)
             {
                 if (m_brush != brush) {
                     m_brush = brush;
                     update();
                 }
             }
             /*!
                 Returns the brush used by legend.
             */
             QBrush QLegend::brush() const
             {
                 return m_brush;
             }
             /*!
                 Sets the \a pen of legend. Pen affects the legend borders.
             */
             void QLegend::setPen(const QPen &pen)
             {
                 if (m_pen != pen) {
                     m_pen = pen;
                     update();
                 }
             }
             /*!
                 Returns the pen used by legend
             */
             QPen QLegend::pen() const
             {
                 return m_pen;
             }
             /*!
                 Sets the \a preferred layout for legend. Legend tries to paint itself on the defined position in chart.
                 \sa QLegend::Layout
             */
             void QLegend::setAlignmnent(QLegend::Alignments alignment)
             {
-            //    if (!m_attachedToChart) {
+                if(m_alignment!=alignment && m_attachedToChart) {
                     m_alignment = alignment;
                     updateLayout();
-                    m_chart->resize(m_chart->size());
-            //    }
             }
             /*!
                 Returns the preferred layout for legend
             */
             QLegend::Alignments QLegend::alignment() const
             {
                 return m_alignment;
             }
             /*!
-                Returns the maximum size of legend.
-            */
-            QSizeF QLegend::maximumSize() const
-                return m_maximumSize;
-            /*!
-                Sets the maximum \a size for legend. The legend can't grow bigger than this size. If there are
-                more series than legend can fit to this size, scroll buttons are displayed.
-            */
-            void QLegend::setMaximumSize(const QSizeF size)
-                m_maximumSize = size;
-                updateLayout();
-            /*!
-                Returns the current size of legend.
-            */
-            QSizeF QLegend::size() const
-                return m_size;
-            /*!
-                Sets the \a size of legend. If size is bigger than maximum size of legend, the legend is resized to the maximum size.
-                \sa setMmaximumSize()
-            */
-            void QLegend::setSize(const QSizeF size)
-                m_size = size;
-                if (m_size.width() > m_maximumSize.width()) {
-                    m_size.setWidth(m_maximumSize.width());
-                if (m_size.height() > m_maximumSize.height()) {
-                    m_size.setHeight(m_maximumSize.height());
-            /*!
-                Sets position of legend to \a pos
-            */
-            void QLegend::setPos(const QPointF &pos)
-                m_pos = pos;
-                updateLayout();
-            /*!
                 \internal \a series \a domain Should be called when series is added to chart.
             */
             void QLegend::handleSeriesAdded(QSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
                 switch (series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries *lineSeries = static_cast<QLineSeries *>(series);
                     appendMarkers(lineSeries);
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries *areaSeries = static_cast<QAreaSeries *>(series);
                     appendMarkers(areaSeries);
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries *barSeries = static_cast<QBarSeries *>(series);
                     appendMarkers(barSeries);
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries *stackedBarSeries = static_cast<QStackedBarSeries *>(series);
                     appendMarkers(stackedBarSeries);
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries *percentBarSeries = static_cast<QPercentBarSeries *>(series);
                     appendMarkers(percentBarSeries);
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                     QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
                     appendMarkers(scatterSeries);
                     break;
                 }
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     appendMarkers(pieSeries);
                     connect(pieSeries,SIGNAL(added(QList<QPieSlice*>)),this,SLOT(handleAdded(QList<QPieSlice*>)));
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
                     QSplineSeries *splineSeries = static_cast<QSplineSeries *>(series);
                     appendMarkers(splineSeries);
                     break;
                 }
                 default: {
                     qWarning()<< "QLegend::handleSeriesAdded" << series->type() << "unknown series type.";
                     break;
                 }
                 }
-                updateLayout();
+               // wait for all series added
+               if(!m_dirty){
+            	   QTimer::singleShot(0,this,SLOT(updateLayout()));
+            	   m_dirty=true;
+               }
             }
             /*!
                 \internal \a series Should be called when series is removed from chart.
             */
             void QLegend::handleSeriesRemoved(QSeries *series)
             {
                 switch (series->type())
                 {
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries *areaSeries = static_cast<QAreaSeries *>(series);
                     deleteMarkers(areaSeries);
                     break;
                 }
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     disconnect(pieSeries, SIGNAL(added(QList<QPieSlice *>)), this, SLOT(handleAdded(QList<QPieSlice *>)));
                     deleteMarkers(series);
                     break;
                 }
                 default: {
                     // All other types
                     deleteMarkers(series);
                     break;
                 }
                 }
                 updateLayout();
             }
             /*!
                 \internal \a slices Should be called when slices are added to pie chart.
             */
             void QLegend::handleAdded(QList<QPieSlice *> slices)
             {
                 QPieSeries* series = static_cast<QPieSeries *> (sender());
-                foreach(QPieSlice* s, slices) {
+                foreach(QPieSlice* slice, slices) {
-                    LegendMarker* marker = new LegendMarker(series, s, this);
+                    PieLegendMarker* marker = new PieLegendMarker(series,slice, this);
-                    marker->setName(s->label());
-                    marker->setBrush(s->brush());
-                    connect(marker, SIGNAL(clicked(QPieSlice*,Qt::MouseButton)),
-                            this, SIGNAL(clicked(QPieSlice*,Qt::MouseButton)));
-                    connect(s, SIGNAL(changed()), marker, SLOT(changed()));
-                    connect(s, SIGNAL(destroyed()), marker, SLOT(deleteLater()));
                     connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
-                    m_markers.append(marker);
+                    m_markers->addToGroup(marker);
-                    childItems().append(marker);
                 }
                 updateLayout();
             }
             /*!
                 \internal \a slices Should be called when slices are removed from pie chart. Currently unused,
                 because removed slices are also deleted and we listen destroyed signal
             */
             void QLegend::handleRemoved(QList<QPieSlice *> slices)
             {
                 Q_UNUSED(slices)
             }
             /*!
                 \internal Notifies legend that some marker has been removed. Sent by legend markers when destroyed
             */
             void QLegend::handleMarkerDestroyed()
             {
                 LegendMarker* m = static_cast<LegendMarker *> (sender());
-                m_markers.removeOne(m);
+                delete m;
-                updateLayout();
+               // updateLayout();
-            /*!
-                \internal \a event Handles clicked signals from scroll buttons
-            */
-            void QLegend::scrollButtonClicked(LegendScrollButton *scrollButton)
-                 Q_ASSERT(scrollButton);
-                switch (scrollButton->id()) {
-                case LegendScrollButton::ScrollButtonIdLeft:
-                case LegendScrollButton::ScrollButtonIdUp: {
-                    // Lower limit is same in these cases
-                    mFirstMarker--;
-                    checkFirstMarkerBounds();
-                    break;
-                case LegendScrollButton::ScrollButtonIdRight:
-                case LegendScrollButton::ScrollButtonIdDown: {
-                    mFirstMarker++;
-                    checkFirstMarkerBounds();
-                    break;
-                default: {
-                    break;
-                updateLayout();
             }
             /*!
                 Detaches the legend from chart. Chart won't change layout of the legend.
             */
             void QLegend::detachFromChart()
             {
                 m_attachedToChart = false;
             }
             /*!
                 Attaches the legend to chart. Chart may change layout of the legend.
             */
             void QLegend::attachToChart()
             {
                 m_attachedToChart = true;
             }
             /*!
                 Returns true, if legend is attached to chart.
             */
-            bool QLegend::attachedToChart()
+            bool QLegend::isAttachedToChart()
             {
                 return m_attachedToChart;
             }
             /*!
                 \internal Helper function. Appends markers from \a series to legend.
             */
             void QLegend::appendMarkers(QAreaSeries* series)
             {
-                LegendMarker* marker = new LegendMarker(series,this);
+                AreaLegendMarker* marker = new AreaLegendMarker(series,this);
-                connect(marker, SIGNAL(clicked(QSeries *, Qt::MouseButton)), this, SIGNAL(clicked(QSeries *, Qt::MouseButton)));
                 connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
-                connect(series,SIGNAL(updated()),marker,SLOT(changed()));
+                m_markers->addToGroup(marker);
-                marker->changed();
-                m_markers.append(marker);
-                childItems().append(marker);
             }
             /*!
                 \internal Helper function. Appends markers from \a series to legend.
             */
             void QLegend::appendMarkers(QXYSeries* series)
             {
-                LegendMarker* marker = new LegendMarker(series,this);
+                XYLegendMarker* marker = new XYLegendMarker(series,this);
-                connect(marker, SIGNAL(clicked(QSeries *, Qt::MouseButton)), this, SIGNAL(clicked(QSeries *, Qt::MouseButton)));
                 connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
-                connect(series,SIGNAL(updated()),marker,SLOT(changed()));
+                m_markers->addToGroup(marker);
-                marker->changed();
-                m_markers.append(marker);
-                childItems().append(marker);
             }
             /*!
                 \internal Helper function. Appends markers from \a series to legend.
             */
             void QLegend::appendMarkers(QBarSeries *series)
             {
                 foreach(QBarSet* set, series->barSets()) {
-                    LegendMarker* marker = new LegendMarker(series, set, this);
+                    BarLegendMarker* marker = new BarLegendMarker(series,set, this);
-                    connect(marker, SIGNAL(clicked(QBarSet *, Qt::MouseButton)),
-                            this, SIGNAL(clicked(QBarSet *, Qt::MouseButton)));
-                    connect(set, SIGNAL(valueChanged()), marker, SLOT(changed()));
                     connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
-                    marker->changed();
+                    m_markers->addToGroup(marker);
-                    m_markers.append(marker);
-                    childItems().append(marker);
                 }
             }
             /*!
                 \internal Helper function. Appends markers from \a series to legend.
             */
             void QLegend::appendMarkers(QPieSeries *series)
             {
                 foreach(QPieSlice* slice, series->slices()) {
-                    LegendMarker* marker = new LegendMarker(series, slice, this);
+                    PieLegendMarker* marker = new PieLegendMarker(series,slice, this);
-                    connect(marker, SIGNAL(clicked(QPieSlice *, Qt::MouseButton)),
-                            this, SIGNAL(clicked(QPieSlice *, Qt::MouseButton)));
-                    connect(slice, SIGNAL(changed()), marker, SLOT(changed()));
-                    connect(slice, SIGNAL(destroyed()), marker, SLOT(deleteLater()));
                     connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
-                    marker->changed();
+                    m_markers->addToGroup(marker);
-                    m_markers.append(marker);
-                    childItems().append(marker);
                 }
             }
             /*!
                 \internal Deletes all markers that are created from \a series
             */
             void QLegend::deleteMarkers(QSeries *series)
             {
                 // Search all markers that belong to given series and delete them.
-                foreach (LegendMarker *m, m_markers) {
-                    if (m->series() == series) {
+                QList<QGraphicsItem *> items = m_markers->childItems();
-                        m_markers.removeOne(m);
-                        delete m;
+                foreach (QGraphicsItem *m, items) {
+                    LegendMarker *marker = static_cast<LegendMarker*>(m);
+                    if (marker->series() == series) {
+                        delete marker;
                     }
                 }
             }
             /*!
                 \internal Updates layout of legend. Tries to fit as many markers as possible up to the maximum size of legend.
                 If items don't fit, sets the visibility of scroll buttons accordingly.
                 Causes legend to be resized.
             */
-            void QLegend::updateLayout()
-                // Calculate layout for markers and text
-                if (m_markers.count() <= 0) {
-                    // Nothing to do
-                    return;
-                checkFirstMarkerBounds();
+            void QLegend::setOffset(const QPointF& point)
+            {
-                switch (m_alignment)
+                switch(m_alignment) {
-                // Both cases organise items horizontally
-                case QLegend::AlignmentBottom:
-                case QLegend::AlignmentTop: {
-                    layoutHorizontal();
-                    break;
-                // Both cases organize items vertically
-                case QLegend::AlignmentLeft:
-                case QLegend::AlignmentRight: {
-                    layoutVertical();
-                    break;
-                default: {
-                    break;
+                    case AlignmentTop:
+                    case AlignmentBottom: {
+                        if(m_width<=m_rect.width()) return;
-            /*!
+                        if (point.x() != m_offsetX) {
-                \internal Organizes markers horizontally.
+                            m_offsetX = qBound(0.0, point.x(), m_width - m_rect.width());
-                Causes legend to be resized.
+                            m_markers->setPos(-m_offsetX,m_rect.top());
-            */
-            void QLegend::layoutHorizontal()
-                // Find out widest item.
-                QSizeF markerMaxSize = maximumMarkerSize();
-                // Use max height as scroll button size
-                rescaleScrollButtons(QSize(markerMaxSize.height() ,markerMaxSize.height()));
-                qreal totalWidth = 0;
-                qreal totalHeight = 0;
-                qreal xStep = markerMaxSize.width();
-                qreal x = m_pos.x() + m_margin;
-                qreal y = m_pos.y() + m_margin;
-                int column = 0;
-                int maxColumns = 1;
-                qreal scrollButtonWidth = 0;
-                // Set correct visibility for scroll scrollbuttons
-                if (scrollButtonsVisible()) {
-                    m_scrollButtonLeft->setVisible(true);
-                    m_scrollButtonRight->setVisible(true);
-                    // scrollbuttons visible, so add their width to total width
-                    totalWidth += (m_scrollButtonLeft->boundingRect().width() + m_margin) * 2;
-                    scrollButtonWidth = m_scrollButtonLeft->boundingRect().width() + m_margin;
-                    // start position changes by scrollbutton width
-                    x += scrollButtonWidth;
-                } else {
-                    m_scrollButtonLeft->setVisible(false);
-                    m_scrollButtonRight->setVisible(false);
-                m_scrollButtonUp->setVisible(false);
-                m_scrollButtonDown->setVisible(false);
-                for (int i=0; i < m_markers.count(); i++) {
-                    LegendMarker *m = m_markers.at(i);
-                    if (i < mFirstMarker) {
-                        // Markers before first are not visible.
-                        m->setVisible(false);
-                    } else {
-                        if ((x + xStep + scrollButtonWidth + m_margin) > (m_pos.x() + m_maximumSize.width())) {
-                            // This marker would go outside legend rect.
-                            m->setVisible(false);
-                        } else {
-                            // This marker is ok
-                            m->setVisible(true);
-                            m->setPos(x, y);
-                            x += xStep;
-                            column++;
                         }
+                        break;
                     }
-                    maxColumns = column;
+                    case AlignmentLeft:
+                    case AlignmentRight: {
-                m_scrollButtonLeft->setPos(m_pos.x() + m_margin, y);
-                m_scrollButtonRight->setPos(x + m_margin, y);
-                totalWidth += maxColumns * markerMaxSize.width() + m_margin * 2;
+                        if(m_height<=m_rect.height()) return;
-                totalHeight = markerMaxSize.height() + m_margin * 2;
-                m_size.setWidth(totalWidth);
+                        if (point.y() != m_offsetY) {
-                m_size.setHeight(totalHeight);
+                            m_offsetY = qBound(0.0, point.y(), m_height - m_rect.height());
+                            m_markers->setPos(m_rect.left(),-m_offsetY);
-            /*!
-                \internal Organizes markers vertically.
-                Causes legend to be resized.
-            */
-            void QLegend::layoutVertical()
-                // Find out widest item.
-                QSizeF markerMaxSize = maximumMarkerSize();
-                // Use max height as scroll button size
-                rescaleScrollButtons(QSize(markerMaxSize.height() ,markerMaxSize.height()));
-                qreal totalWidth = 0;
-                qreal totalHeight = 0;
-                qreal yStep = markerMaxSize.height();
-                qreal x = m_pos.x() + m_margin;
-                qreal y = m_pos.y() + m_margin;
-                int row = 1;
-                int maxRows = 1;
-                qreal scrollButtonHeight = 0;
-                // Set correct visibility for scroll scrollbuttons
-                if (scrollButtonsVisible()) {
-                    m_scrollButtonUp->setVisible(true);
-                    m_scrollButtonDown->setVisible(true);
-                    totalHeight += (m_scrollButtonUp->boundingRect().height() + m_margin) * 2;   // scrollbuttons visible, so add their height to total height
-                    scrollButtonHeight = m_scrollButtonUp->boundingRect().height();
-                    y += scrollButtonHeight + m_margin;                                         // start position changes by scrollbutton height
-                } else {
-                    m_scrollButtonUp->setVisible(false);
-                    m_scrollButtonDown->setVisible(false);
-                m_scrollButtonLeft->setVisible(false);
-                m_scrollButtonRight->setVisible(false);
-                for (int i=0; i < m_markers.count(); i++) {
-                    LegendMarker* m = m_markers.at(i);
-                    if (i < mFirstMarker) {
-                        // Markers before first are not visible.
-                        m->setVisible(false);
-                    } else {
-                        if ((y + yStep + scrollButtonHeight) > (m_pos.y() + m_maximumSize.height())) {
-                            // This marker would go outside legend rect.
-                            m->setVisible(false);
-                        } else {
-                            // This marker is ok
-                            m->setVisible(true);
-                            m->setPos(x, y);
-                            y += yStep;
-                            row++;
                         }
+                        break;
                     }
-                    maxRows = row;
                 }
+            }
-                m_scrollButtonUp->setPos(m_pos.x() + m_margin, m_pos.y() + m_margin);
+            QPointF QLegend::offset() const
-                m_scrollButtonDown->setPos(m_pos.x() + m_margin, y + m_margin);
+                return QPointF(m_offsetX,m_offsetY);
-                totalWidth += markerMaxSize.width() + m_margin * 2;
-                totalHeight = maxRows * markerMaxSize.height() + m_margin * 4 + scrollButtonHeight; // TODO: check this
-                m_size.setWidth(totalWidth);
-                m_size.setHeight(totalHeight);
             }
-            /*!
+            // this function runs first to set min max values
-                \internal Sets the size of scroll buttons to \a size
+            void QLegend::updateLayout()
-            */
-            void QLegend::rescaleScrollButtons(const QSize &size)
             {
-                QPolygonF left;
+            	m_dirty=false;
-                left << QPointF(size.width(), 0) << QPointF(0, size.height() / 2) << QPointF(size.width(), size.height());
+            	m_offsetX=0;
-                QPolygonF right;
+                QList<QGraphicsItem *> items = m_markers->childItems();
-                right << QPointF(0, 0) << QPointF(size.width(), size.height() / 2) << QPointF(0, size.height());
-                QPolygonF up;
+                if(items.isEmpty()) return;
-                up << QPointF(0, size.height()) << QPointF(size.width() / 2,0) << QPointF(size.width(), size.height());
-                QPolygonF down;
+                m_minWidth=0;
-                down << QPointF(0, 0) << QPointF(size.width() / 2, size.height()) << QPointF(size.width(), 0);
+                m_minHeight=0;
+                switch(m_alignment) {
+                    case AlignmentTop:
+                    case AlignmentBottom: {
+                        QPointF point = m_rect.topLeft();
+                        m_width = 0;
+                        foreach (QGraphicsItem *item, items) {
+                            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 AlignmentLeft:
+                    case AlignmentRight:{
+                        QPointF point = m_rect.topLeft();
+                        m_height = 0;
+                        foreach (QGraphicsItem *item, items) {
+                            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_scrollButtonLeft->setPolygon(left);
+                m_chart->d_ptr->m_presenter->updateLayout(); //TODO fixme;
-                m_scrollButtonRight->setPolygon(right);
-                m_scrollButtonUp->setPolygon(up);
-                m_scrollButtonDown->setPolygon(down);
             }
-            /*!
+            void QLegend::setBackgroundVisible(bool visible)
-                \internal Finds out maximum size of single marker. Marker sizes depend on series names.
-            */
+                if(m_visible!=visible)
-            QSizeF QLegend::maximumMarkerSize()
+                	m_visible=visible;
-                QSizeF max(0,0);
+                	update();
-                foreach (LegendMarker* m, m_markers) {
-                    if (m->boundingRect().width() > max.width())
-                        max.setWidth(m->boundingRect().width());
-                    if (m->boundingRect().height() > max.height())
-                        max.setHeight(m->boundingRect().height());
                 }
-                return max;
             }
-            /*!
+            bool QLegend::isBackgroundVisible() const
-                \internal Checks that first marker is in acceptable bounds. Bounds range from 0 to (maximum number of markers - visible markers)
-                If scrollbuttons are visible, they affect the number of visible markers.
+               return m_visible;
-            */
-            void QLegend::checkFirstMarkerBounds()
-                if ((m_alignment == QLegend::AlignmentLeft) || (m_alignment == QLegend::AlignmentRight)) {
-                    // Bounds limited by height.
-                    int max;
-                    if (scrollButtonsVisible()) {
-                        max = (m_maximumSize.height() - m_scrollButtonLeft->boundingRect().height() * 2 - m_margin * 4) / maximumMarkerSize().height();
-                    } else {
-                        max = m_maximumSize.height() / maximumMarkerSize().height();
-                    if (mFirstMarker > m_markers.count() - max)
-                        mFirstMarker = m_markers.count() - max;
-                } else {
-                    // Bounds limited by width
-                    int max;
-                    if (scrollButtonsVisible()) {
-                        max = (m_maximumSize.width() - m_scrollButtonLeft->boundingRect().width() * 2 - m_margin*4) / maximumMarkerSize().width();
-                    } else {
-                        max = m_maximumSize.width() / maximumMarkerSize().width();
-                    if (mFirstMarker > m_markers.count() - max)
+            void QLegend::resizeEvent(QGraphicsSceneResizeEvent *event)
-                        mFirstMarker = m_markers.count() - max;
+                const QRectF& rect = QRectF(QPoint(0,0),event->newSize());
+                QGraphicsWidget::resizeEvent(event);
+                if(m_rect != rect){
+                    m_rect = rect;
+                    updateLayout();
                 }
+            }
-                if (mFirstMarker < 0)
+            void QLegend::hideEvent(QHideEvent *event)
-                    mFirstMarker = 0;
+                QGraphicsWidget::hideEvent(event);
+                setEnabled(false);
+                updateLayout();
             }
-            /*!
+            void QLegend::showEvent(QShowEvent *event)
-                \internal Helper function. Visibility of scroll buttons isn't quite obvious, so helper function clarifies the logic.
-            */
-            bool QLegend::scrollButtonsVisible()
             {
-                // Just a helper to clarify, what the magic below means :)
+                QGraphicsWidget::showEvent(event);
-                if ((m_alignment == QLegend::AlignmentTop) || (m_alignment == QLegend::AlignmentBottom)) {
+                setEnabled(true);
-                    return (maximumMarkerSize().width() * m_markers.count() + m_margin * 2 > m_maximumSize.width());
+                updateLayout();
-                } else if ((m_alignment == QLegend::AlignmentLeft) || (m_alignment == QLegend::AlignmentRight)) {
-                    return (maximumMarkerSize().height() * m_markers.count() + m_margin * 2 > m_maximumSize.height());
-                return (maximumMarkerSize().height() * m_markers.count() + m_margin * 2 > m_maximumSize.height());
+            void QLegend::mousePressEvent(QGraphicsSceneMouseEvent* event)
+            {
+                //Q_UNUSED(event);
+                m_scroller->mousePressEvent(event);
+            }
+            void QLegend::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
+            {
+                //Q_UNUSED(event);
+                m_scroller->mouseMoveEvent(event);
+            }
+            void QLegend::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
+            {
+                //Q_UNUSED(event);
+                m_scroller->mouseReleaseEvent(event);
             }
             #include "moc_qlegend.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qlegend.h +38 -32

             /****************************************************************************
             **
             ** 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 QSeries;
             class QChart;
+            class Scroller;
             class QTCOMMERCIALCHART_EXPORT QLegend : public QGraphicsWidget
             {
                 Q_OBJECT
             public:
                 // We only support these alignments (for now)
                 enum Alignment {
                     AlignmentTop = Qt::AlignTop,
                     AlignmentBottom = Qt::AlignBottom,
                     AlignmentLeft = Qt::AlignLeft,
                     AlignmentRight = Qt::AlignRight
                 };
                 Q_DECLARE_FLAGS(Alignments, Alignment)
             private:
                 explicit QLegend(QChart *chart);
             public:
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setAlignmnent(QLegend::Alignments alignment);
                 QLegend::Alignments alignment() const;
-                QSizeF maximumSize() const;
-                void setMaximumSize(const QSizeF size);
-                QSizeF size() const;
-                void setSize(const QSizeF size);
-                void setPos(const QPointF &pos);
-                void scrollButtonClicked(LegendScrollButton *scrollButton);
                 void detachFromChart();
                 void attachToChart();
-                bool attachedToChart();
+                bool isAttachedToChart();
+                qreal minWidht() const { return m_minWidth;}
+                qreal minHeight() const { return m_minHeight;}
-            Q_SIGNALS:
+                void setBackgroundVisible(bool visible);
-                // for interactions.
+                bool isBackgroundVisible() const;
-                void clicked(QSeries *series, Qt::MouseButton button);
-                void clicked(QBarSet *barset, Qt::MouseButton button);
+                void setOffset(const QPointF& point);
-                void clicked(QPieSlice *slice, Qt::MouseButton button);
+                QPointF offset() const;
-                void legendGeometryChanged();
+            protected:
+                void resizeEvent(QGraphicsSceneResizeEvent *event);
+                void hideEvent(QHideEvent *event);
+                void showEvent(QShowEvent *event);
+                void mousePressEvent(QGraphicsSceneMouseEvent* event);
+                void mouseMoveEvent(QGraphicsSceneMouseEvent* event);
+                void mouseReleaseEvent(QGraphicsSceneMouseEvent* event);
             public Q_SLOTS:
                 // PIMPL --->
                 void handleSeriesAdded(QSeries *series, Domain *domain);
                 void handleSeriesRemoved(QSeries *series);
                 void handleAdded(QList<QPieSlice *> slices);
                 void handleRemoved(QList<QPieSlice *> slices);
                 void handleMarkerDestroyed();
                 // PIMPL <---
             private:
                 // PIMPL --->
                 void appendMarkers(QAreaSeries *series);
                 void appendMarkers(QXYSeries *series);
                 void appendMarkers(QBarSeries *series);
                 void appendMarkers(QPieSeries *series);
                 void deleteMarkers(QSeries *series);
+            private Q_SLOTS:
                 void updateLayout();
-                void layoutHorizontal();
+                void scroll();
-                void layoutVertical();
-                void rescaleScrollButtons(const QSize &size);
-                QSizeF maximumMarkerSize();
-                void checkFirstMarkerBounds();
-                bool scrollButtonsVisible();
+            private:
                 qreal m_margin;
-                QPointF m_pos;
-                QSizeF m_minimumSize;
-                QSizeF m_maximumSize;
-                QSizeF m_size;
-                QList<LegendMarker *> m_markers;
+                QRectF m_rect;
+                qreal m_offsetX;
+                qreal m_offsetY;
+                //QList<LegendMarker *> m_markers;
                 QBrush m_brush;
                 QPen m_pen;
                 QLegend::Alignments m_alignment;
+                QGraphicsItemGroup* m_markers;
-                int mFirstMarker;
-                LegendScrollButton *m_scrollButtonLeft;
-                LegendScrollButton *m_scrollButtonRight;
-                LegendScrollButton *m_scrollButtonUp;
-                LegendScrollButton *m_scrollButtonDown;
                 bool m_attachedToChart;
                 QChart *m_chart;
+                qreal m_minWidth;
+                qreal m_minHeight;
+                qreal m_width;
+                qreal m_height;
+                bool m_visible;
+                bool m_dirty;
+                Scroller* m_scroller;
                 friend class QChart;
                 // <--- PIMPL
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGEND_H

src/src.pro +4 -2

             !include( ../common.pri ):error( Couldn't find the common.pri file! )
             TARGET = QtCommercialChart
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT += core \
                 gui
             win32-msvc*: LIBS += User32.lib
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QtCommercialChartd
             SOURCES += \
                 $$PWD/chartdataset.cpp \
                 $$PWD/chartpresenter.cpp \
                 $$PWD/charttheme.cpp \
                 $$PWD/domain.cpp \
                 $$PWD/qchart.cpp \
                 $$PWD/qchartview.cpp \
                 $$PWD/qseries.cpp \
                 $$PWD/qlegend.cpp \
                 $$PWD/legendmarker.cpp \
                 $$PWD/legendscrollbutton.cpp \
                 $$PWD/chartbackground.cpp \
-                $$PWD/chart.cpp
+                $$PWD/chart.cpp \
+                $$PWD/scroller.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartdataset_p.h \
                 $$PWD/chartitem_p.h \
                 $$PWD/chartpresenter_p.h \
                 $$PWD/charttheme_p.h \
                 $$PWD/domain_p.h \
                 $$PWD/legendmarker_p.h \
                 $$PWD/legendscrollbutton_p.h \
                 $$PWD/chartbackground_p.h \
                 $$PWD/chart_p.h \
                 $$PWD/chartconfig_p.h \
                 $$PWD/qchart_p.h \
-                $$PWD/qchartview_p.h
+                $$PWD/qchartview_p.h \
+                $$PWD/scroller_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qchart.h \
                 $$PWD/qchartglobal.h \
                 $$PWD/qseries.h \
                 $$PWD/qchartview.h \
                 $$PWD/qlegend.h
             include(animations/animations.pri)
             include(axis/axis.pri)
             include(xychart/xychart.pri)
             include(linechart/linechart.pri)
             include(areachart/areachart.pri)
             include(barchart/barchart.pri)
             include(piechart/piechart.pri)
             include(scatterseries/scatter.pri)
             include(splinechart/splinechart.pri)
             include(themes/themes.pri)
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             INCLUDEPATH += ../include .
             OBJECTS_DIR = $$CHART_BUILD_DIR/lib
             MOC_DIR = $$CHART_BUILD_DIR/lib
             UI_DIR = $$CHART_BUILD_DIR/lib
             RCC_DIR = $$CHART_BUILD_DIR/lib
             DEFINES += QTCOMMERCIALCHART_LIBRARY
             #qt public headers
             #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"
                 }
                 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)
                 }
             }
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS $$PUBLIC_QT_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target 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-msvc*: {
                 # 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
                 chartversion.target = $$PWD/qchartversion_p.h
                 unix:{
                     chartversion.commands = @echo \
                         "const char *buildTime = \\\"`date +'%y%m%d%H%M'`\\\" \\; \
                          const char *gitHead = \\\"`git rev-parse HEAD`\\\" \\; " \
                         > \
                         $$chartversion.target;
                 }else{
                     chartversion.commands = @echo \
                         "const char *buildTime = \"%date%_%time%\" ; \
                          const char *gitHead = \"unknown\" ; " \
                         > \
                         $$chartversion.target
                 }
                 chartversion.depends = $$HEADERS \
                     $$SOURCES
                 PRE_TARGETDEPS += $$PWD/qchartversion_p.h
                 QMAKE_CLEAN += $$PWD/qchartversion_p.h
                 QMAKE_EXTRA_TARGETS += chartversion
             }
             unix:QMAKE_DISTCLEAN += -r \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             win32:QMAKE_DISTCLEAN += /Q \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             # treat warnings as errors
             win32-msvc*: {
                 QMAKE_CXXFLAGS += /WX
             } else {
                 QMAKE_CXXFLAGS += -Werror
             }

src/xychart/qxyseries.h +2 -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$
             **
             ****************************************************************************/
             #ifndef QXYSERIES_H_
             #define QXYSERIES_H_
             #include <qchartglobal.h>
             #include <qseries.h>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QXYSeries : public QSeries
             {
                 Q_OBJECT
             protected:
                 QXYSeries(QObject *parent = 0);
                 virtual ~QXYSeries();
             public:
                 void append(qreal x, qreal y);
                 void append(const QPointF &point);
                 void append(const QList<QPointF> points);
                 void replace(qreal x,qreal y);
                 void replace(const QPointF &point);
                 void remove(qreal x);
                 void remove(qreal x, qreal y);
                 void remove(const QPointF &point);
                 void removeAll();
                 int count() const;
                 qreal x(int pos) const;
                 qreal y(int pos) const;
                 QList<QPointF> data();
                 QXYSeries& operator << (const QPointF &point);
                 QXYSeries& operator << (const QList<QPointF> points);
                 void setPen(const QPen &pen);
                 QPen pen() const {return m_pen;}
                 void setBrush(const QBrush &brush);
                 QBrush brush() const {return m_brush;}
                 bool setModel(QAbstractItemModel *model);
                 QAbstractItemModel* model() const { return m_model; }
                 virtual void setModelMapping(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
                 virtual void setModelMappingShift(int first, int count = 0);
                 int mapFirst() const { return m_mapFirst; }
             private Q_SLOTS:
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelDataAboutToBeAdded(QModelIndex parent, int start, int end);
                 void modelDataAdded(QModelIndex parent, int start, int end);
                 void modelDataAboutToBeRemoved(QModelIndex parent, int start, int end);
                 void modelDataRemoved(QModelIndex parent, int start, int end);
             Q_SIGNALS:
                 void clicked(const QPointF &point);
+                void selected();
                 void updated();
                 void pointReplaced(int index);
                 void pointRemoved(int index);
                 void pointAdded(int index);
             protected:
                 QVector<qreal> m_x;
                 QVector<qreal> m_y;
                 QPen m_pen;
                 QBrush m_brush;
                 int m_mapX;
                 int m_mapY;
                 int m_mapFirst;
                 int m_mapCount;
                 bool m_mapLimited;
                 Qt::Orientation m_mapOrientation;
                 int tempItemsRemoved;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

test/auto/qchartview/tst_qchartview.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 <QtTest/QtTest>
             #include <qchartview.h>
             #include <qlineseries.h>
             #include <cmath>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QChart*)
             Q_DECLARE_METATYPE(QChartView::RubberBands)
             Q_DECLARE_METATYPE(Qt::Key)
             class tst_QChartView : public QObject
             {
                 Q_OBJECT
             public Q_SLOTS:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private Q_SLOTS:
                 void qchartview_data();
                 void qchartview();
                 void chart_data();
                 void chart();
                 void rubberBand_data();
                 void rubberBand();
                 void keys_data();
                 void keys();
             private:
                 QChartView* m_view;
             };
             void tst_QChartView::initTestCase()
             {
                 //test tracks mouse, give a while to user to relese it
                 QTest::qWait(1000);
             }
             void tst_QChartView::cleanupTestCase()
             {
             }
             void tst_QChartView::init()
             {
                 m_view = new QChartView(new QChart());
             }
             void tst_QChartView::cleanup()
             {
                 delete m_view;
                 m_view =0;
             }
             void tst_QChartView::qchartview_data()
             {
             }
             void tst_QChartView::qchartview()
             {
                 QVERIFY(m_view->chart());
                 QCOMPARE(m_view->rubberBand(), QChartView::NoRubberBand);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QChartView::chart_data()
             {
                 QTest::addColumn<QChart*>("chart");
                 QTest::newRow("qchart") << new QChart();
             }
             void tst_QChartView::chart()
             {
                 QFETCH(QChart*, chart);
                 QChartView* view = new QChartView(chart);
                 QCOMPARE(view->chart(), chart);
                 delete view;
             }
             void tst_QChartView::rubberBand_data()
             {
                 QTest::addColumn<QChartView::RubberBands>("rubberBand");
                 QTest::addColumn<int>("Xcount");
                 QTest::addColumn<int>("Ycount");
                 QTest::addColumn<int>("minX");
                 QTest::addColumn<int>("maxX");
                 QTest::addColumn<int>("minY");
                 QTest::addColumn<int>("maxY");
                 QTest::newRow("HorizonalRubberBand") << QChartView::RubberBands(QChartView::HorizonalRubberBand) << 0 << 1 << 10 << 90 << 0<< 100;
                 QTest::newRow("VerticalRubberBand") <<  QChartView::RubberBands(QChartView::VerticalRubberBand) << 1 << 0 << 0 << 100 << 10<< 90;
                 QTest::newRow("RectangleRubberBand") <<  QChartView::RubberBands(QChartView::RectangleRubberBand) << 1 << 1 <<10 << 90 << 10<< 90;
             }
             void tst_QChartView::rubberBand()
             {
                 QFETCH(QChartView::RubberBands, rubberBand);
                 QFETCH(int, Xcount);
                 QFETCH(int, Ycount);
                 QFETCH(int, minX);
                 QFETCH(int, maxX);
                 QFETCH(int, minY);
                 QFETCH(int, maxY);
                 m_view->setRubberBand(rubberBand);
-                QRect padding = m_view->chart()->padding();
+                QRect padding = m_view->chart()->margins();
                 QCOMPARE(m_view->rubberBand(), rubberBand);
                 QLineSeries* line = new QLineSeries();
                 *line << QPointF(0, 0) << QPointF(100, 100);
                 m_view->chart()->addSeries(line);
                 m_view->resize(100 + padding.left() + padding.right(), 100 +  padding.top()+ padding.bottom());
                 m_view->show();
                 //this is hack since view does not get events otherwise
                 m_view->setMouseTracking(true);
                 QChartAxis* axisY = m_view->chart()->axisY();
                 QSignalSpy spy0(axisY, SIGNAL(rangeChanged(qreal, qreal)));
                 QChartAxis* axisX = m_view->chart()->axisX();
                 QSignalSpy spy1(axisX, SIGNAL(rangeChanged(qreal, qreal)));
                 QTest::qWaitForWindowShown(m_view);
                 QTest::mouseMove(m_view->viewport(),  QPoint(minX, minY) + padding.topLeft());
                 QTest::mousePress(m_view->viewport(), Qt::LeftButton, 0,  QPoint(minX, minY) + padding.topLeft());
                 QTest::mouseMove(m_view->viewport(), QPoint(maxX, maxY) + padding.topLeft());
                 QTest::mouseRelease(m_view->viewport(), Qt::LeftButton, 0, QPoint(maxX, maxY)+ padding.topLeft());
                 QCOMPARE(spy0.count(), Xcount);
                 QCOMPARE(spy1.count(), Ycount);
                 //this is hack since view does not get events otherwise
                 m_view->setMouseTracking(false);
                 QVERIFY(axisX->min() - minX < 1);
                 QVERIFY(axisX->max() - maxX < 1);
                 QVERIFY(axisY->min() - minY < 1);
                 QVERIFY(axisY->max() - maxY < 1);
             }
             void tst_QChartView::keys_data()
             {
                 QTest::addColumn<Qt::Key>("key");
                 QTest::addColumn<int>("Xcount");
                 QTest::addColumn<int>("Ycount");
                 QTest::newRow("Qt::Key_Plus") << Qt::Key_Plus << 1 << 1;
                 QTest::newRow("Qt::Key_Minus") << Qt::Key_Minus << 1 << 1;
                 QTest::newRow("Qt::Key_Up") << Qt::Key_Up << 0 << 1;
                 QTest::newRow("Qt::Key_Down") << Qt::Key_Down << 0 << 1;
                 QTest::newRow("Qt::Key_Left") << Qt::Key_Left << 1 << 0;
                 QTest::newRow("Qt::Key_Right") << Qt::Key_Right << 1 << 0;
             }
             void tst_QChartView::keys()
             {
                 QFETCH(Qt::Key,key);
                 QFETCH(int, Xcount);
                 QFETCH(int, Ycount);
-                QRect padding = m_view->chart()->padding();
+                QRect padding = m_view->chart()->margins();
                 QLineSeries* line = new QLineSeries();
                 *line << QPointF(0, 0) << QPointF(100, 100);
                 m_view->chart()->addSeries(line);
                 m_view->resize(100 + padding.left() + padding.right(), 100 +  padding.top()+ padding.bottom());
                 m_view->show();
                 QChartAxis* axisY = m_view->chart()->axisY();
                 QSignalSpy spy0(axisY, SIGNAL(rangeChanged(qreal, qreal)));
                 QChartAxis* axisX = m_view->chart()->axisX();
                 QSignalSpy spy1(axisX, SIGNAL(rangeChanged(qreal, qreal)));
                 QTest::keyPress(m_view, key);
                 QTest::keyRelease(m_view, key);
                 QCOMPARE(spy0.count(), Ycount);
                 QCOMPARE(spy1.count(), Xcount);
             }
             QTEST_MAIN(tst_QChartView)
             #include "tst_qchartview.moc"

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