HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1167:494db513d752

new series: groupedbarseries

sauimone -

r1167:494db513d752

parent child

Context file:

r1167:494db513d752

Expand all files

examples/groupedbarchart/groupedbarchart.pro created 644 +8 0

@@ -0,0 +1,8
	1	!include( ../examples.pri ) {
	2	error( "Couldn't find the examples.pri file!" )
	3	}
	4
	5	TARGET = groupedbarchart
	6	SOURCES += main.cpp
	7
	8	!system_build:mac: QMAKE_POST_LINK += "$$MAC_POST_LINK_PREFIX $$MAC_EXAMPLES_BIN_DIR"

examples/groupedbarchart/main.cpp created 644 +89 0

@@ -0,0 +1,89
	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 <QApplication>
	22	#include <QMainWindow>
	23	#include <QChartView>
	24	#include <QGroupedBarSeries>
	25	#include <QBarSet>
	26	#include <QLegend>
	27
	28	QTCOMMERCIALCHART_USE_NAMESPACE
	29
	30	int main(int argc, char *argv[])
	31	{
	32	QApplication a(argc, argv);
	33
	34	//![1]
	35	QBarCategories categories;
	36	categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
	37	//![1]
	38
	39	//![2]
	40	QBarSet *set0 = new QBarSet("Jane");
	41	QBarSet *set1 = new QBarSet("John");
	42	QBarSet *set2 = new QBarSet("Axel");
	43	QBarSet *set3 = new QBarSet("Mary");
	44	QBarSet *set4 = new QBarSet("Samantha");
	45
	46	*set0 << 1 << 2 << 3 << 4 << 5 << 6;
	47	*set1 << 5 << 0 << 0 << 4 << 0 << 7;
	48	*set2 << 3 << 5 << 8 << 13 << 8 << 5;
	49	*set3 << 5 << 6 << 7 << 3 << 4 << 5;
	50	*set4 << 9 << 7 << 5 << 3 << 1 << 2;
	51	//![2]
	52
	53	//![3]
	54	QGroupedBarSeries* series = new QGroupedBarSeries();
	55	series->setCategories(categories);
	56	series->appendBarSet(set0);
	57	series->appendBarSet(set1);
	58	series->appendBarSet(set2);
	59	series->appendBarSet(set3);
	60	series->appendBarSet(set4);
	61
	62	//![3]
	63
	64	//![4]
	65	QChart* chart = new QChart();
	66	chart->addSeries(series);
	67	chart->setTitle("Simple grouped barchart example");
	68	//![4]
	69
	70	//![5]
	71	chart->legend()->setVisible(true);
	72	chart->legend()->setAlignment(QLegend::AlignmentBottom);
	73	chart->axisY()->setNiceNumbersEnabled(true);
	74	//![5]
	75
	76	//![6]
	77	QChartView* chartView = new QChartView(chart);
	78	chartView->setRenderHint(QPainter::Antialiasing);
	79	//![6]
	80
	81	//![7]
	82	QMainWindow window;
	83	window.setCentralWidget(chartView);
	84	window.resize(400, 300);
	85	window.show();
	86	//![7]
	87
	88	return a.exec();
	89	}

src/barchart/groupedbarchartitem.cpp created 644 +87 0

@@ -0,0 +1,87
	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 "groupedbarchartitem_p.h"
	22	#include "bar_p.h"
	23	#include "barlabel_p.h"
	24	#include "qbarset_p.h"
	25	#include "qbarseries_p.h"
	26	#include "qbarset.h"
	27
	28	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	29
	30	GroupedBarChartItem::GroupedBarChartItem(QBarSeries series, ChartPresenter presenter) :
	31	BarChartItem(series, presenter)
	32	{
	33	}
	34
	35	QVector<QRectF> GroupedBarChartItem::calculateLayout()
	36	{
	37	QVector<QRectF> layout;
	38
	39	// Use temporary qreals for accurancy
	40	qreal categoryCount = m_series->categoryCount();
	41	qreal setCount = m_series->barsetCount();
	42
	43	// Domain:
	44	qreal width = geometry().width();
	45	qreal height = geometry().height();
	46	qreal range = m_domainMaxY - m_domainMinY;
	47	qreal scale = (height / range);
	48	qreal categoryWidth = width / categoryCount;
	49	qreal barWidth = categoryWidth / (setCount+1);
	50
	51	int itemIndex(0);
	52	for (int category = 0; category < categoryCount; category++) {
	53	qreal xPos = categoryWidth * category + barWidth / 2 + geometry().topLeft().x();
	54	qreal yPos = height + scale * m_domainMinY + geometry().topLeft().y();
	55	for (int set = 0; set < setCount; set++) {
	56	QBarSet* barSet = m_series->d_func()->barsetAt(set);
	57
	58	qreal barHeight = barSet->at(category).y() * scale;
	59	Bar* bar = m_bars.at(itemIndex);
	60
	61	QRectF rect(xPos, yPos - barHeight, barWidth, barHeight);
	62	layout.append(rect);
	63	bar->setPen(barSet->pen());
	64	bar->setBrush(barSet->brush());
	65
	66	BarLabel* label = m_labels.at(itemIndex);
	67
	68	if (!qFuzzyIsNull(barSet->at(category).y())) {
	69	label->setText(QString::number(barSet->at(category).y()));
	70	} else {
	71	label->setText(QString(""));
	72	}
	73
	74	label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
	75	,yPos - barHeight/2 - label->boundingRect().height()/2);
	76	label->setFont(barSet->labelFont());
	77
	78	itemIndex++;
	79	xPos += barWidth;
	80	}
	81	}
	82	return layout;
	83	}
	84
	85	#include "moc_groupedbarchartitem_p.cpp"
	86
	87	QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/groupedbarchartitem_p.h created 644 +47 0

@@ -0,0 +1,47
	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	#ifndef GROUPEDBARCHARTITEM_H
	22	#define GROUPEDBARCHARTITEM_H
	23
	24	#include "barchartitem_p.h"
	25	#include "qstackedbarseries.h"
	26	#include <QGraphicsItem>
	27
	28	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	29
	30	class GroupedBarChartItem : public BarChartItem
	31	{
	32	Q_OBJECT
	33	public:
	34	GroupedBarChartItem(QBarSeries series, ChartPresenter presenter);
	35
	36	private:
	37	// From BarChartItem
	38	virtual QVector<QRectF> calculateLayout();
	39
	40	private:
	41
	42	// Data
	43	};
	44
	45	QTCOMMERCIALCHART_END_NAMESPACE
	46
	47	#endif // GROUPEDBARCHARTITEM_H

src/barchart/qgroupedbarseries.cpp created 644 +108 0

@@ -0,0 +1,108
	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 "qgroupedbarseries.h"
	22	#include "qgroupedbarseries_p.h"
	23	#include "groupedbarchartitem_p.h"
	24	#include "chartdataset_p.h"
	25	#include "charttheme_p.h"
	26	#include "chartanimator_p.h"
	27
	28	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	29
	30	/*!
	31	\class QGroupedBarSeries
	32	\brief part of QtCommercial chart API.
	33	\mainclass
	34
	35	QGroupedBarSeries represents a series of data shown as bars. All bars in same category are
	36	grouped next to each other. One QGroupedBarSeries can contain multiple QBarSet data sets.
	37	QGroupedBarSeries groups the data from sets to categories, which are defined by QStringList.
	38
	39	See the \l {GroupedbarChart Example} {grouped bar chart example} to learn how to create a grouped bar chart.
	40	\image examples_groupedbarchart.png
	41
	42	\sa QBarSet, QPercentBarSeries, QBarSeries, QStackedBarSeries
	43	*/
	44
	45	/*!
	46	\fn virtual QSeriesType QGroupedBarSeries::type() const
	47	\brief Returns type of series.
	48	\sa QSeriesType
	49	*/
	50
	51	/*!
	52	Constructs empty QGroupedBarSeries. Parameter \a categories defines the categories for chart.
	53	QGroupedBarSeries is QObject which is a child of a \a parent.
	54	*/
	55	QGroupedBarSeries::QGroupedBarSeries(QObject *parent)
	56	: QBarSeries(*new QGroupedBarSeriesPrivate(this), parent)
	57	{
	58	}
	59
	60	QAbstractSeries::SeriesType QGroupedBarSeries::type() const
	61	{
	62	return QAbstractSeries::SeriesTypeGroupedBar;
	63	}
	64
	65	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	66
	67	QGroupedBarSeriesPrivate::QGroupedBarSeriesPrivate(/QBarCategories categories,/ QGroupedBarSeries q) : QBarSeriesPrivate(/categories,*/q)
	68	{
	69
	70	}
	71
	72	void QGroupedBarSeriesPrivate::scaleDomain(Domain& domain)
	73	{
	74	qreal minX(domain.minX());
	75	qreal minY(domain.minY());
	76	qreal maxX(domain.maxX());
	77	qreal maxY(domain.maxY());
	78	int tickXCount(domain.tickXCount());
	79	int tickYCount(domain.tickYCount());
	80
	81	qreal x = m_categories.count();
	82	qreal y = maxCategorySum();
	83	minX = qMin(minX, x);
	84	minY = qMin(minY, y);
	85	maxX = qMax(maxX, x);
	86	maxY = qMax(maxY, y);
	87	tickXCount = x+1;
	88
	89	domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
	90	}
	91
	92
	93	Chart* QGroupedBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
	94	{
	95	Q_Q(QGroupedBarSeries);
	96
	97	GroupedBarChartItem* bar = new GroupedBarChartItem(q,presenter);
	98	if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
	99	presenter->animator()->addAnimation(bar);
	100	}
	101	presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
	102	return bar;
	103	}
	104
	105	#include "moc_qgroupedbarseries.cpp"
	106
	107	QTCOMMERCIALCHART_END_NAMESPACE
	108

src/barchart/qgroupedbarseries.h created 644 +45 0

@@ -0,0 +1,45
	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	#ifndef GROUPEDBARSERIES_H
	22	#define GROUPEDBARSERIES_H
	23
	24	#include <QStringList>
	25	#include <qbarseries.h>
	26
	27	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	28
	29	class QGroupedBarSeriesPrivate;
	30
	31	class QTCOMMERCIALCHART_EXPORT QGroupedBarSeries : public QBarSeries
	32	{
	33	Q_OBJECT
	34	public:
	35	explicit QGroupedBarSeries(QObject *parent = 0);
	36	QAbstractSeries::SeriesType type() const;
	37
	38	private:
	39	Q_DECLARE_PRIVATE(QGroupedBarSeries)
	40	Q_DISABLE_COPY(QGroupedBarSeries)
	41	};
	42
	43	QTCOMMERCIALCHART_END_NAMESPACE
	44
	45	#endif // GROUPEDBARSERIES_H

src/barchart/qgroupedbarseries_p.h created 644 +52 0

@@ -0,0 +1,52
	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 QGROUPEDBARSERIES_P_H
	31	#define QGROUPEDBARSERIES_P_H
	32
	33	#include "qbarseries_p.h"
	34	#include "domain_p.h"
	35
	36	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	37
	38
	39	class QGroupedBarSeriesPrivate: public QBarSeriesPrivate
	40	{
	41	public:
	42	QGroupedBarSeriesPrivate(QGroupedBarSeries* q);
	43	Chart* createGraphics(ChartPresenter* presenter);
	44	void scaleDomain(Domain& domain);
	45
	46	private:
	47	Q_DECLARE_PUBLIC(QGroupedBarSeries)
	48	};
	49
	50	QTCOMMERCIALCHART_END_NAMESPACE
	51
	52	#endif // QGROUPEDBARSERIES_P_H

examples/barchart/main.cpp +6 -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$
             **
             ****************************************************************************/
             #include <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QBarSeries>
             #include <QBarSet>
             #include <QLegend>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QBarCategories categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
             //![1]
             //![2]
                 QBarSet *set0 = new QBarSet("Jane");
                 QBarSet *set1 = new QBarSet("John");
                 QBarSet *set2 = new QBarSet("Axel");
                 QBarSet *set3 = new QBarSet("Mary");
                 QBarSet *set4 = new QBarSet("Samantha");
-                *set0 << 1 << 2 << 3 << 4 << 5 << 6;
+                *set0 << QPointF(0.0, 1) << QPointF(1.0, 2) << QPointF(2.0, 3) << QPointF(3.0, 4) << QPointF(4.0, 5) << QPointF(5.0, 6);
-                *set1 << 5 << 0 << 0 << 4 << 0 << 7;
+                *set1 << QPointF(0.2, 2) << QPointF(1.2, 3) << QPointF(2.2, 4) << QPointF(3.2, 5) << QPointF(4.2, 6) << QPointF(5.2, 7);
-                *set2 << 3 << 5 << 8 << 13 << 8 << 5;
+                *set2 << QPointF(0.4, 3) << QPointF(1.4, 4) << QPointF(2.4, 5) << QPointF(3.4, 6) << QPointF(4.4, 7) << QPointF(5.4, 8);
-                *set3 << 5 << 6 << 7 << 3 << 4 << 5;
+                *set3 << QPointF(0.6, 4) << QPointF(1.6, 5) << QPointF(2.6, 6) << QPointF(3.6, 7) << QPointF(4.6, 8) << QPointF(5.6, 9);
-                *set4 << 9 << 7 << 5 << 3 << 1 << 2;
+                *set4 << QPointF(0.8, 5) << QPointF(1.8, 6) << QPointF(2.8, 7) << QPointF(3.8, 8) << QPointF(4.8, 9) << QPointF(5.8, 10);
             //![2]
             //![3]
                 QBarSeries* series = new QBarSeries();
                 series->setCategories(categories);
                 series->appendBarSet(set0);
                 series->appendBarSet(set1);
                 series->appendBarSet(set2);
                 series->appendBarSet(set3);
                 series->appendBarSet(set4);
             //![3]
             //![4]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Simple barchart example");
             //![4]
             //![5]
                 chart->legend()->setVisible(true);
                 chart->legend()->setAlignment(QLegend::AlignmentBottom);
                 chart->axisY()->setNiceNumbersEnabled(true);
             //![5]
             //![6]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![6]
             //![7]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![7]
                 return a.exec();
             }

examples/examples.pro +2 -1

             CURRENTLY_BUILDING_COMPONENTS = "examples"
             !include( ../config.pri ) {
                 error( "Couldn't find the config.pri file!" )
             }
             TEMPLATE = subdirs
             SUBDIRS += \
                        areachart \
                        barchart \
                        customchart \
                        linechart \
                        percentbarchart \
                        piechart \
                        piechartdrilldown \
                        presenterchart \
                        scatterchart \
                        scatterinteractions \
                        splinechart \
                        stackedbarchart \
                        stackedbarchartdrilldown \
                        zoomlinechart \
-                       modeldata
+                       modeldata \
+                       groupedbarchart

src/barchart/barchart.pri +8 -3

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/bar.cpp \
                 $$PWD/barchartitem.cpp \
                 $$PWD/percentbarchartitem.cpp \
+                $$PWD/groupedbarchartitem.cpp \
                 $$PWD/qbarseries.cpp \
                 $$PWD/qbarset.cpp \
                 $$PWD/qpercentbarseries.cpp \
                 $$PWD/qstackedbarseries.cpp \
+                $$PWD/qgroupedbarseries.cpp \
                 $$PWD/stackedbarchartitem.cpp \
-                $$PWD/barlabel.cpp
+                $$PWD/barlabel.cpp \
             PRIVATE_HEADERS += \
                 $$PWD/bar_p.h \
                 $$PWD/barchartitem_p.h \
                 $$PWD/percentbarchartitem_p.h \
                 $$PWD/stackedbarchartitem_p.h \
+                $$PWD/groupedbarchartitem_p.h \
                 $$PWD/barlabel_p.h \
                 $$PWD/qbarset_p.h \
                 $$PWD/qbarseries_p.h \
                 $$PWD/qstackedbarseries_p.h\
-                $$PWD/qpercentbarseries_p.h
+                $$PWD/qpercentbarseries_p.h \
+                $$PWD/qgroupedbarseries_p.h \
             PUBLIC_HEADERS += \
                 $$PWD/qbarseries.h \
                 $$PWD/qbarset.h \
                 $$PWD/qpercentbarseries.h \
-                $$PWD/qstackedbarseries.h
+                $$PWD/qstackedbarseries.h \
+                $$PWD/qgroupedbarseries.h

src/barchart/barchartitem.cpp +12 -10

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "barchartitem_p.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qbarseries.h"
             #include "qbarseries_p.h"
             #include "qchart.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include "chartdataset_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartItem::BarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 ChartItem(presenter),
                 m_layoutSet(false),
                 m_series(series)
             {
                 setFlag(ItemClipsChildrenToShape);
                 connect(series->d_func(), SIGNAL(updatedBars()), this, SLOT(handleLayoutChanged()));
                 connect(series->d_func(), SIGNAL(restructuredBars()), this, SLOT(handleModelChanged()));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 dataChanged();
             }
             BarChartItem::~BarChartItem()
             {
             }
             void BarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             QRectF BarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void BarChartItem::dataChanged()
             {
                 foreach(QGraphicsItem *item, childItems()) {
                     delete item;
                 }
                 m_bars.clear();
                 m_labels.clear();
                 m_layout.clear();
                 // Create new graphic items for bars
                 for (int c = 0; c < m_series->categoryCount(); c++) {
                     QString category = m_series->d_func()->categoryName(c);
                     for (int s = 0; s < m_series->barsetCount(); s++) {
                         QBarSet *set = m_series->d_func()->barsetAt(s);
                         Bar *bar = new Bar(set,category,this);
                         m_bars.append(bar);
                         connect(bar, SIGNAL(clicked(QString)), set, SIGNAL(clicked(QString)));
                         connect(bar, SIGNAL(clicked(QBarSet*,QString)), m_series, SIGNAL(clicked(QBarSet*,QString)));
                         connect(bar, SIGNAL(hovered(bool)), set, SIGNAL(hovered(bool)));
                         connect(bar, SIGNAL(hovered(QBarSet*,bool)), m_series, SIGNAL(hovered(QBarSet*,bool)));
                         m_layout.append(QRectF(0, 0, 0, 0));
                     }
                 }
                 // Create labels
                 for (int category = 0; category < m_series->categoryCount(); category++) {
                     for (int s = 0; s < m_series->barsetCount(); s++) {
                         QBarSet *set = m_series->d_func()->barsetAt(s);
                         BarLabel *value = new BarLabel(*set, this);
                         m_labels.append(value);
                         connect(set->d_ptr.data(),SIGNAL(labelsVisibleChanged(bool)),value,SLOT(labelsVisibleChanged(bool)));
                     }
                 }
                 // TODO: Is this the right place to call it?
             //    presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
             }
             QVector<QRectF> BarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accurancy
                 qreal categoryCount = m_series->categoryCount();
                 qreal setCount = m_series->barsetCount();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
-                qreal range = m_domainMaxY - m_domainMinY;
+                qreal rangeY = m_domainMaxY - m_domainMinY;
-                qreal scale = (height / range);
+                qreal rangeX = m_domainMaxX - m_domainMinX;
+                qreal scaleY = (height / rangeY);
+                qreal scaleX = (width / rangeX);
                 qreal categoryWidth = width / categoryCount;
-                qreal barWidth = categoryWidth / (setCount+1);
+                qreal barWidth = categoryWidth - categoryWidth * m_series->d_func()->barMargin();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
-                    qreal xPos = categoryWidth * category + barWidth / 2 + geometry().topLeft().x();
+                    qreal yPos = height + scaleY * m_domainMinY + geometry().topLeft().y();
-                    qreal yPos = height + scale * m_domainMinY + geometry().topLeft().y();
                     for (int set = 0; set < setCount; set++) {
                         QBarSet* barSet = m_series->d_func()->barsetAt(set);
+                        qreal xPos = (barSet->at(category).x() - m_domainMinX) * scaleX + m_rect.left() - barWidth/2;
+                        qreal barHeight = barSet->at(category).y() * scaleY;
-                        qreal barHeight = barSet->at(category) * scale;
                         Bar* bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - barHeight, barWidth, barHeight);
                         layout.append(rect);
                         bar->setPen(barSet->pen());
                         bar->setBrush(barSet->brush());
                         BarLabel* label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(barSet->at(category))) {
+                        if (!qFuzzyIsNull(barSet->at(category).y())) {
-                            label->setText(QString::number(barSet->at(category)));
+                            label->setText(QString::number(barSet->at(category).y()));
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->labelFont());
                         itemIndex++;
-                        xPos += barWidth;
                     }
                 }
                 return layout;
             }
             void BarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator())
                     animator()->updateLayout(this, m_layout, layout);
                 else
                     setLayout(layout);
             }
             void BarChartItem::setLayout(const QVector<QRectF> &layout)
             {
                 m_layout = layout;
                 for (int i=0; i < m_bars.count(); i++)
                     m_bars.at(i)->setRect(layout.at(i));
                 update();
             }
             //handlers
             void BarChartItem::handleModelChanged()
             {
             //    dataChanged();
                 presenter()->resetAllElements();
             }
             void BarChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_domainMinX = minX;
                 m_domainMaxX = maxX;
                 m_domainMinY = minY;
                 m_domainMaxY = maxY;
                 handleLayoutChanged();
             }
             void BarChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 handleLayoutChanged();
                 m_layoutSet = true;
             }
             void BarChartItem::handleLayoutChanged()
             {
                 if ((m_rect.width() <= 0) || (m_rect.height() <= 0)) {
                     // rect size zero.
                     return;
                 }
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
                 update();
             }
             #include "moc_barchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/percentbarchartitem.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 "percentbarchartitem_p.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "qbarseries_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarChartItem::PercentBarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }
             QVector<QRectF> PercentBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accurancy
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal categoryCount = m_series->categoryCount();
                 qreal barWidth = width / (m_series->categoryCount() * 2);
                 qreal xStep = width / categoryCount;
                 qreal xPos =  xStep / 2 - barWidth / 2 + geometry().topLeft().x();
                 qreal range = m_domainMaxY - m_domainMinY;
                 qreal domainScale = (height / range);
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal colSum = m_series->d_func()->categorySum(category);
                     qreal percentage = (100 / colSum);
                     qreal yPos = height + domainScale * m_domainMinY + geometry().topLeft().y();
                     for (int set=0; set < m_series->barsetCount(); set++) {
                         QBarSet* barSet = m_series->d_func()->barsetAt(set);
-                        qreal barHeight = barSet->at(category) * percentage * domainScale;
+                        qreal barHeight = barSet->at(category).y() * percentage * domainScale;
                         Bar* bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->pen());
                         bar->setBrush(barSet->brush());
                         QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         BarLabel* label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(m_series->d_func()->valueAt(set,category))) {
                             int p = m_series->d_func()->percentageAt(set,category) * 100;
                             QString vString(QString::number(p));
                             vString.truncate(3);
                             vString.append("%");
                             label->setText(vString);
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->labelFont());
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 return layout;
             }
             #include "moc_percentbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.cpp +24 -8

             /****************************************************************************
             **
             ** 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 "qbarseries.h"
             #include "qbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include <QAbstractItemModel>
             #include <QModelIndex>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 \mainclass
                 QBarSeries represents a series of data shown as bars. One QBarSeries can contain multiple
                 QBarSet data sets. QBarSeries groups the data from sets to categories, which are defined
                 by QStringList.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn void QBarSeries::clicked(QBarSet *barset, QString category)
                 The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset of category \a category
                 contained by the series.
             */
             /*!
                 \fn void QBarSeries::hovered(QBarSet* barset, bool status)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 Constructs empty QBarSeries. Parameter \a categories defines the categories for chart.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(/*QBarCategories categories,*/ QObject *parent) :
                 QAbstractSeries(*new QBarSeriesPrivate(/*categories,*/ this),parent)
             {
             }
             /*!
                 Destructs barseries and owned barsets.
             */
             QBarSeries::~QBarSeries()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
                 \internal
             */
             QBarSeries::QBarSeries(QBarSeriesPrivate &d, QObject *parent) :
                 QAbstractSeries(d,parent)
             {
             }
             /*!
                 Returns the type of series. Derived classes override this.
             */
             QAbstractSeries::SeriesType QBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBar;
             }
             void QBarSeries::setCategories(QBarCategories categories)
             {
                 Q_D(QBarSeries);
                 d->setCategories(categories);
                 emit d->categoriesUpdated();
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set.
             */
             bool QBarSeries::appendBarSet(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 if ((d->m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;
                 }
                 d->m_barSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
                 emit d->restructuredBars();
                 return true;
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesn't delete \a set.
             */
             bool QBarSeries::removeBarSet(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 if (!d->m_barSets.contains(set)) {
                     // Fail if set is not in list
                     return false;
                 }
                 d->m_barSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
                 emit d->restructuredBars();
                 return true;
             }
             /*!
                 Adds a list of barsets to series. Takes ownership of \a sets.
             */
             bool QBarSeries::appendBarSets(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
                 foreach (QBarSet* set, sets) {
                     if ((set == 0) || (d->m_barSets.contains(set))) {
                         // Fail if any of the sets is null or is already appended.
                         return false;
                     }
                     if (sets.count(set) != 1) {
                         // Also fail if same set is more than once in given list.
                         return false;
                     }
                 }
                 foreach (QBarSet* set, sets) {
                     d->m_barSets.append(set);
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
                 }
                 emit d->restructuredBars();
                 return true;
             }
             /*!
                 Removes a list of barsets from series. Releases ownership of \a sets. Doesn't delete \a sets.
             */
             bool QBarSeries::removeBarSets(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
                 bool setsRemoved = false;
                 foreach (QBarSet* set, sets) {
                     if (d->m_barSets.contains(set)) {
                         d->m_barSets.removeOne(set);
                         QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
                         setsRemoved = true;
                     }
                 }
                 if (setsRemoved) {
                     emit d->restructuredBars();
                 }
                 return setsRemoved;
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::barsetCount() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns number of categories in series
             */
             int QBarSeries::categoryCount() const
             {
                 Q_D(const QBarSeries);
                 return d->m_categories.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets;
             }
             /*!
                  \fn bool QBarSeries::setModel(QAbstractItemModel *model)
                  Sets the \a model to be used as a data source
              */
             void QBarSeries::setModel(QAbstractItemModel */*model*/)
             {
             //    Q_D(QBarSeries);
             //    d->setModel(model);
             }
             /*!
                  \fn bool QBarSeries::setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation)
                  Sets column/row specified by \a categories to be used as a list of bar series categories.
                  Parameter \a bottomBoundry indicates the column/row where the first bar set is located in the model.
                  Parameter \a topBoundry indicates the column/row where the last bar set is located in the model.
                  All the columns/rows inbetween those two values are also used as data for bar sets.
                  The \a orientation parameter specifies whether the data is in columns or in rows.
              */
             //void QBarSeries::setModelMapping(int categories, int bottomBoundary, int topBoundary, Qt::Orientation orientation)
             //{
             //    Q_D(QBarSeries);
             //    d->setModelMapping(categories,bottomBoundary,topBoundary,orientation);
             //}
             //void QBarSeries::setModelMappingRange(int first, int count)
             //{
             //    Q_D(QBarSeries);
             //    d->setModelMappingRange(first, count);
             //}
             /*!
                 Returns the bar categories of the series.
             */
             QBarCategories QBarSeries::categories() const
             {
                 Q_D(const QBarSeries);
                 return d->m_categories;
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QBarSeries::setLabelsVisible(bool visible)
             {
                 foreach (QBarSet* s, barSets()) {
                     s->setLabelsVisible(visible);
                 }
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QBarSeriesPrivate::QBarSeriesPrivate(/*QBarCategories categories,*/ QBarSeries *q) :
+            QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) :
                 QAbstractSeriesPrivate(q),
-            //    m_categories(categories),
+                m_barMargin(0.05),  // Default value is 5% of category width
                 m_mapCategories(-1),
                 m_mapBarBottom(-1),
                 m_mapBarTop(-1)
             {
             }
             void QBarSeriesPrivate::setCategories(QBarCategories categories)
             {
                 m_categories = categories;
             }
+            void QBarSeriesPrivate::setBarMargin(qreal margin)
+            {
+                if (margin > 1.0) {
+                    margin = 1.0;
+                } else if (margin < 0.0) {
+                    margin = 0.0;
+                }
+                m_barMargin = margin;
+                emit updatedBars();
+            }
+            qreal QBarSeriesPrivate::barMargin()
+            {
+                return m_barMargin;
+            }
             QBarSet* QBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             QString QBarSeriesPrivate::categoryName(int category)
             {
                 return m_categories.at(category);
             }
             qreal QBarSeriesPrivate::min()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
-                        qreal temp = m_barSets.at(i)->at(j);
+                        qreal temp = m_barSets.at(i)->at(j).y();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QBarSeriesPrivate::max()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
-                        qreal temp = m_barSets.at(i)->at(j);
+                        qreal temp = m_barSets.at(i)->at(j).y();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QBarSeriesPrivate::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
-                return m_barSets.at(set)->at(category);
+                return m_barSets.at(set)->at(category).y();
             }
             qreal QBarSeriesPrivate::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
-                qreal value = m_barSets.at(set)->at(category);
+                qreal value = m_barSets.at(set)->at(category).y();
                 qreal sum = categorySum(category);
                 if ( qFuzzyIsNull(sum) ) {
                     return 0;
                 }
                 return value / sum;
             }
             qreal QBarSeriesPrivate::categorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
-                        sum += m_barSets.at(set)->at(category);
+                        sum += m_barSets.at(set)->at(category).y();
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::absoluteCategorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
-                        sum += qAbs(m_barSets.at(set)->at(category));
+                        sum += qAbs(m_barSets.at(set)->at(category).y());
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = m_categories.count();
                 for (int i = 0; i < count; i++) {
                     qreal sum = categorySum(i);
                     if (sum > max)
                         max = sum;
                 }
                 return max;
             }
             //void QBarSeriesPrivate::setModel(QAbstractItemModel *model)
             //{
             //    // disconnect signals from old model
             //    if(m_model)
             //    {
             //        disconnect(m_model, 0, this, 0);
             //        m_mapCategories = -1;
             //        m_mapBarBottom = -1;
             //        m_mapBarTop = -1;
             //        m_mapOrientation = Qt::Vertical;
             //    }
             //    // set new model
             //    if(model)
             //    {
             //        m_model = model;
             //    }
             //    else
             //    {
             //        m_model = 0;
             //    }
             //}
             //void QBarSeriesPrivate::setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation)
             //{
             //    Q_Q(QBarSeries);
             //    if (m_model == 0)
             //        return;
             //    m_mapCategories = categories;
             //    m_mapBarBottom = bottomBoundry;
             //    m_mapBarTop = topBoundry;
             //    m_mapOrientation = orientation;
             //    // connect the signals
             //    connect(m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex,QModelIndex)));
             //    if (m_mapOrientation == Qt::Vertical) {
             //        connect(m_model,SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
             //        connect(m_model,SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
             //    } else {
             //        connect(m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
             //        connect(m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
             //    }
             //    // create the initial bars
             //    m_categories.clear();
             //    if (m_mapOrientation == Qt::Vertical) {
             //        int rowCount = 0;
             //        if(m_mapCount == -1)
             //            rowCount = m_model->rowCount() - m_mapFirst;
             //        else
             //            rowCount = qMin(m_mapCount, m_model->rowCount() - m_mapFirst);
             //        for (int k = m_mapFirst; k < m_mapFirst + rowCount; k++) {
             //            m_categories << m_model->data(m_model->index(k, m_mapCategories), Qt::DisplayRole).toString();
             //        }
             //        for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
             //            QBarSet* barSet = new QBarSet(m_model->headerData(i, Qt::Horizontal, Qt::DisplayRole).toString());
             //            for(int m = m_mapFirst; m < m_mapFirst + rowCount; m++)
             //                *barSet << m_model->data(m_model->index(m, i), Qt::DisplayRole).toDouble();
             //            q->appendBarSet(barSet);
             //        }
             //    } else {
             //        int columnCount = 0;
             //        if(m_mapCount == -1)
             //            columnCount = m_model->columnCount() - m_mapFirst;
             //        else
             //            columnCount = qMin(m_mapCount, m_model->columnCount() - m_mapFirst);
             //        for (int k = m_mapFirst; k < m_mapFirst + columnCount; k++) {
             //            m_categories << m_model->data(m_model->index(m_mapCategories, k), Qt::DisplayRole).toString();
             //        }
             //        for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
             //            QBarSet* barSet = new QBarSet(m_model->headerData(i, Qt::Vertical, Qt::DisplayRole).toString());
             //            for(int m = m_mapFirst; m < m_mapFirst + columnCount; m++)
             //                *barSet << m_model->data(m_model->index(i, m), Qt::DisplayRole).toDouble();
             //            q->appendBarSet(barSet);
             //        }
             //    }
             //}
             //void QBarSeriesPrivate::setModelMappingRange(int first, int count)
             //{
             //    m_mapFirst = first;
             //    m_mapCount = count;
             //}
             //void QBarSeriesPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             //{
             //    for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
             //        for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
             //            if (m_mapOrientation == Qt::Vertical)
             //            {
             //                // model update is relevant to BarSeries if the change was made to the part of the model that was mapped to BarSeries
             //                if ( row >= m_mapFirst && (m_mapCount == - 1 || row < m_mapFirst + m_mapCount)) {
             //                    if (column >= m_mapBarBottom && column <= m_mapBarTop)
             //                        barsetAt(column - m_mapBarBottom)->replace(row - m_mapFirst, m_model->data(topLeft, Qt::DisplayRole).toDouble());
             //                    //                    if (column == m_mapCategories);// TODO:
             //                }
             //            }
             //            else
             //            {
             //                // model update is relevant to BarSeries if the change was made to the part of the model that was mapped to BarSeries
             //                if (column >= m_mapFirst && (m_mapCount == - 1 || column < m_mapFirst + m_mapCount)) {
             //                    if (row >= m_mapBarBottom && row <= m_mapBarTop)
             //                        barsetAt(row - m_mapBarBottom)->replace(column - m_mapFirst, m_model->data(topLeft, Qt::DisplayRole).toDouble());
             //                    //                    if (row == m_mapCategories);// TODO:
             //                }
             //            }
             //        }
             //    }
             //}
             void QBarSeriesPrivate::modelDataAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(start);
                 Q_UNUSED(end);
             //    initializeDataFromModel();
             //    // series uses model as a data sourceupda
             //    int addedCount = end - start + 1;
             //    if (m_mapCount != -1 && start >= m_mapFirst + m_mapCount) {
             //        return;
             //    } else {
             //        for (int bar = m_mapBarBottom; bar <= m_mapBarTop; bar++) {
             //            QBarSet *barSet = barsetAt(bar - m_mapBarBottom);
             //            // adding items to unlimited map
             //            if (m_mapCount == -1 && start >= m_mapFirst) {
             //                for (int i = start; i <= end; i++) {
             //                    if (bar == m_mapBarBottom)
             //                        insertCategory(i - m_mapFirst, m_model->data(m_model->index(i, m_mapCategories), Qt::DisplayRole).toString());
             //                    barSet->insert(i - m_mapFirst, m_model->data(m_model->index(i, bar), Qt::DisplayRole).toDouble());
             //                }
             //            } else if (m_mapCount == - 1 && start < m_mapFirst) {
             //                // not all newly added items
             //                for (int i = m_mapFirst; i < m_mapFirst + addedCount; i++) {
             //                    if (bar == m_mapBarBottom)
             //                        insertCategory(i - m_mapFirst, m_model->data(m_model->index(i, m_mapCategories), Qt::DisplayRole).toString());
             //                    barSet->insert(i - m_mapFirst, m_model->data(m_model->index(i, bar), Qt::DisplayRole).toDouble());
             //                }
             //            }
             //            // adding items to limited map
             //            else if (start >= m_mapFirst) {
             //                // remove the items that will no longer fit into the map
             //                // int toRemove = addedCount - (count - points().size());
             //                for (int i = start; i <= end; i++) {
             //                    if (bar == m_mapBarBottom)
             //                        insertCategory(i - m_mapFirst, m_model->data(m_model->index(i, m_mapCategories), Qt::DisplayRole).toString());
             //                    barSet->insert(i - m_mapFirst, m_model->data(m_model->index(i, bar), Qt::DisplayRole).toDouble());
             //                }
             //                if (m_barSets.size() > m_mapCount)
             //                    for (int i = m_barSets.size() - 1; i >= m_mapCount; i--) {
             //                        if (bar == m_mapBarBottom)
             //                            removeCategory(i);
             //                        barSet->remove(i);
             //                    }
             //            } else {
             //                //
             //                for (int i = m_mapFirst; i < m_mapFirst + addedCount; i++) {
             //                    if (bar == m_mapBarBottom)
             //                        insertCategory(i - m_mapFirst, m_model->data(m_model->index(i, m_mapCategories), Qt::DisplayRole).toString());
             //                    barSet->insert(i - m_mapFirst, m_model->data(m_model->index(i, bar), Qt::DisplayRole).toDouble());
             //                }
             //                if (m_barSets.size() > m_mapCount)
             //                    for (int i = m_barSets.size() - 1; i >= m_mapCount; i--) {
             //                        if (bar == m_mapBarBottom)
             //                            removeCategory(i);
             //                        barSet->remove(i);
             //                    }
             //            }
             //        }
             //        emit restructuredBars();
             //        emit barsetChanged();
             //        emit categoriesUpdated();
             //    }
             }
             void QBarSeriesPrivate::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(start);
                 Q_UNUSED(end);
             //    initializeDataFromModel();
             }
             //void QBarSeriesPrivate::initializeDataFromModel()
             //{
             //    Q_Q(QBarSeries);
             //    if (m_model == 0)
             //        return;
             //    // connect the signals
             ////    connect(m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex,QModelIndex)));
             ////    if (m_mapOrientation == Qt::Vertical) {
             ////        connect(m_model,SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
             ////        connect(m_model,SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
             ////    } else {
             ////        connect(m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
             ////        connect(m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
             ////    }
             //    // create the initial bars
             //    m_categories.clear();
             //    m_barSets.clear();
             ////    emit restructuredBars();
             //    if (m_mapOrientation == Qt::Vertical) {
             //        int rowCount = 0;
             //        if(m_mapCount == -1)
             //            rowCount = m_model->rowCount() - m_mapFirst;
             //        else
             //            rowCount = qMin(m_mapCount, m_model->rowCount() - m_mapFirst);
             //        for (int k = m_mapFirst; k < m_mapFirst + rowCount; k++) {
             //            m_categories << m_model->data(m_model->index(k, m_mapCategories), Qt::DisplayRole).toString();
             //        }
             //        for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
             //            QBarSet* barSet = new QBarSet(m_model->headerData(i, Qt::Horizontal, Qt::DisplayRole).toString());
             //            for(int m = m_mapFirst; m < m_mapFirst + rowCount; m++)
             //                *barSet << m_model->data(m_model->index(m, i), Qt::DisplayRole).toDouble();
             //            q->appendBarSet(barSet);
             //        }
             //    } else {
             //        int columnCount = 0;
             //        if(m_mapCount == -1)
             //            columnCount = m_model->columnCount() - m_mapFirst;
             //        else
             //            columnCount = qMin(m_mapCount, m_model->columnCount() - m_mapFirst);
             //        for (int k = m_mapFirst; k < m_mapFirst + columnCount; k++) {
             //            m_categories << m_model->data(m_model->index(m_mapCategories, k), Qt::DisplayRole).toString();
             //        }
             //        for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
             //            QBarSet* barSet = new QBarSet(m_model->headerData(i, Qt::Vertical, Qt::DisplayRole).toString());
             //            for(int m = m_mapFirst; m < m_mapFirst + columnCount; m++)
             //                *barSet << m_model->data(m_model->index(i, m), Qt::DisplayRole).toDouble();
             //            q->appendBarSet(barSet);
             //        }
             //    }
             //    emit restructuredBars();
             ////    emit updatedBars();
             //}
             void QBarSeriesPrivate::insertCategory(int index, const QString category)
             {
                 m_categories.insert(index, category);
                 emit categoriesUpdated();
             }
             void QBarSeriesPrivate::removeCategory(int index)
             {
                 m_categories.removeAt(index);
                 emit categoriesUpdated();
             }
             void QBarSeriesPrivate::barsetChanged()
             {
                 emit updatedBars();
             }
             void QBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 qreal x = m_categories.count();
                 qreal y = max();
                 minX = qMin(minX, x);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, x);
                 maxY = qMax(maxY, y);
                 tickXCount = x+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QBarSeries);
                 BarChartItem* bar = new BarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             QList<LegendMarker*> QBarSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QBarSeries);
                 QList<LegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     BarLegendMarker* marker = new BarLegendMarker(q,set,legend);
                     markers << marker;
                 }
                 return markers;
             }
             #include "moc_qbarseries.cpp"
             #include "moc_qbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +2 -4

             /****************************************************************************
             **
             ** 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 <qabstractseries.h>
             #include <QStringList>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             typedef QStringList QBarCategories;
             class QBarSet;
             class BarCategory;
             class QBarSeriesPrivate;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarSeries : public QAbstractSeries
             {
                 Q_OBJECT
             public:
-                explicit QBarSeries(/*QBarCategories categories,*/ QObject *parent = 0);
+                explicit QBarSeries(QObject *parent = 0);
                 virtual ~QBarSeries();
                 QAbstractSeries::SeriesType type() const;
                 void setCategories(QBarCategories categories);
                 bool appendBarSet(QBarSet *set);            // Takes ownership of set
                 bool removeBarSet(QBarSet *set);            // Releases ownership, doesn't delete set
                 bool appendBarSets(QList<QBarSet* > sets);
                 bool removeBarSets(QList<QBarSet* > sets);
                 int barsetCount() const;
                 int categoryCount() const;
                 QList<QBarSet*> barSets() const;
                 QBarCategories categories() const;
                 void setLabelsVisible(bool visible = true);
-            // TODO:
-            //    void setGroupedDrawing(bool on = true);   // By default this is on. Bars are grouped next to each other. If off, bars are drawn at their x-position (propably on top of each other)
-            //    void setBarMargin(int margin);            // Margin that is left between bars (if drawn as grouped bars)
                 void setModel(QAbstractItemModel *model);
             //    void setModelMapping(int categories, int bottomBoundary, int topBoundary, Qt::Orientation orientation = Qt::Vertical);
             //    void setModelMappingRange(int first, int count = -1);
             protected:
                 explicit QBarSeries(QBarSeriesPrivate &d,QObject *parent = 0);
             Q_SIGNALS:
                 void clicked(QBarSet *barset, QString category);
                 void hovered(QBarSet* barset, bool status);
             protected:
                 Q_DECLARE_PRIVATE(QBarSeries)
                 friend class BarChartItem;
                 friend class PercentBarChartItem;
                 friend class StackedBarChartItem;
+                friend class GroupedBarChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/barchart/qbarseries_p.h +4 -1

             #ifndef QBARSERIES_P_H
             #define QBARSERIES_P_H
             #include "qbarseries.h"
             #include "qabstractseries_p.h"
             #include <QStringList>
             #include <QAbstractSeries>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Container for series
             class QBarSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
-                QBarSeriesPrivate(/*QBarCategories categories,*/ QBarSeries *parent);
+                QBarSeriesPrivate(QBarSeries *parent);
                 void setCategories(QBarCategories categories);
+                void setBarMargin(qreal margin);
+                qreal barMargin();
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter* presenter);
                 QList<LegendMarker*> createLegendMarker(QLegend* legend);
             //    void setModel(QAbstractItemModel *model);
             //    void setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation = Qt::Vertical);
             //    void setModelMappingRange(int first, int count = -1);
                 void insertCategory(int index, const QString category);
                 void removeCategory(int index);
                 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();
             Q_SIGNALS:
                 void clicked(QBarSet *barset, QString category);
                 void updatedBars();
                 void restructuredBars();
                 void categoriesUpdated();
             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 initializeDataFromModel();
                 void barsetChanged();
             protected:
                 QList<QBarSet *> m_barSets;
                 QBarCategories m_categories;
+                qreal m_barMargin;
                 int m_mapCategories;
                 int m_mapBarBottom;
                 int m_mapBarTop;
             private:
                 Q_DECLARE_PUBLIC(QBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSERIESPRIVATE_P_H

src/barchart/qbarset.cpp +40 -7

             /****************************************************************************
             **
             ** 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 "qbarset.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSet
                 \brief part of QtCommercial chart API.
                 QBarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 \mainclass
                 \sa QBarSeries, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn void QBarSet::clicked(QString category)
                 \brief signals that set has been clicked
                 Parameter \a category describes on which category was clicked
             */
             /*!
                 \fn void QBarSet::hovered(bool status)
                 \brief signals that mouse has hovered over the set. If \a status is true, then mouse was entered. If \a status is false, then mouse was left.
                 The signal is emitted if mouse is hovered on top of set
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 Constructs QBarSet with a name of \a name and with parent of \a parent
             */
             QBarSet::QBarSet(const QString name, QObject *parent)
                 : QObject(parent)
                 ,d_ptr(new QBarSetPrivate(name,this))
             {
             }
             /*!
                 Destroys the barset
             */
             QBarSet::~QBarSet()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
                 Sets new \a name for set.
             */
             void QBarSet::setName(const QString name)
             {
                 d_ptr->m_name = name;
             }
             /*!
                 Returns name of the set.
             */
             QString QBarSet::name() const
             {
                 return d_ptr->m_name;
             }
+            void QBarSet::append(const QPointF value)
+            {
+                d_ptr->m_values.append(value);
+                emit d_ptr->restructuredBars();
+            }
+            void QBarSet::append(const QList<QPointF> values)
+            {
+                for (int i=0; i<values.count(); i++) {
+                    d_ptr->m_values.append(values.at(i));
+                }
+                emit d_ptr->restructuredBars();
+            }
             /*!
                 Appends new value \a value to the end of set.
             */
             void QBarSet::append(const qreal value)
             {
-                d_ptr->m_values.append(value);
+                append(QPointF(d_ptr->m_values.count(), value));
+            //    d_ptr->m_values.append(value);
+            }
+            void QBarSet::append(const QList<qreal> values)
+            {
+                int index = d_ptr->m_values.count();
+                for (int i=0; i<values.count(); i++) {
+                    d_ptr->m_values.append(QPointF(index,values.at(i)));
+                    index++;
+                }
                 emit d_ptr->restructuredBars();
             }
             /*!
                 Appends new value \a value to the end of set.
             */
             QBarSet& QBarSet::operator << (const qreal &value)
             {
                 append(value);
                 return *this;
             }
+            QBarSet& QBarSet::operator << (const QPointF &value)
+            {
+                append(value);
+                return *this;
+            }
             /*!
                 Inserts new \a value on the \a index position.
                 The value that is currently at this postion is moved to postion index + 1
                 \sa remove()
             */
             void QBarSet::insert(const int index, const qreal value)
             {
-                d_ptr->m_values.insert(index, value);
+                d_ptr->m_values.insert(index, QPointF(index, value));
             //    emit d_ptr->updatedBars();
             }
             /*!
                 Removes the value specified by \a index
                 \sa insert()
             */
             void QBarSet::remove(const int index)
             {
                 d_ptr->m_values.removeAt(index);
             //    emit d_ptr->updatedBars();
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::replace(const int index, const qreal value)
             {
-                d_ptr->m_values.replace(index,value);
+                d_ptr->m_values.replace(index,QPointF(index,value));
                 emit d_ptr->updatedBars();
             }
             /*!
-                Returns value of set indexed by \a index
+                Returns value of set indexed by \a index. Note that all appended values are stored internally as QPointF
             */
-            qreal QBarSet::at(const int index) const
+            QPointF QBarSet::at(const int index) const
             {
                 if (index < 0 || index >= d_ptr->m_values.count())
                     return 0.0;
                 return d_ptr->m_values.at(index);
             }
             /*!
                 Returns value of set indexed by \a index
             */
-            qreal QBarSet::operator [] (int index) const
+            QPointF QBarSet::operator [](const int index) const
             {
                 return d_ptr->m_values.at(index);
             }
             /*!
                 Returns count of values in set.
             */
             int QBarSet::count() const
             {
                 return d_ptr->m_values.count();
             }
             /*!
                 Returns sum of all values in barset.
             */
             qreal QBarSet::sum() const
             {
                 qreal total(0);
                 for (int i=0; i < d_ptr->m_values.count(); i++) {
-                    total += d_ptr->m_values.at(i);
+                    //total += d_ptr->m_values.at(i);
+                    total += d_ptr->m_values.at(i).y();
                 }
                 return total;
             }
             /*!
                 Sets pen for set. Bars of this set are drawn using \a pen
             */
             void QBarSet::setPen(const QPen &pen)
             {
                   if(d_ptr->m_pen!=pen){
                       d_ptr->m_pen = pen;
                       emit d_ptr->updatedBars();
                   }
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBarSet::pen() const
             {
                 return d_ptr->m_pen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
             void QBarSet::setBrush(const QBrush &brush)
             {
                 if(d_ptr->m_brush!=brush){
                   d_ptr->m_brush = brush;
                   emit d_ptr->updatedBars();
                 }
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush() const
             {
                 return d_ptr->m_brush;
             }
             /*!
                 Sets \a pen of the values that are drawn on top of this barset
             */
             void QBarSet::setLabelPen(const QPen &pen)
             {
                 if(d_ptr->m_labelPen!=pen){
                     d_ptr->m_labelPen = pen;
                     emit d_ptr->updatedBars();
                 }
             }
             /*!
                 Returns pen of the values that are drawn on top of this barset
             */
             QPen QBarSet::labelPen() const
             {
                 return d_ptr->m_labelPen;
             }
             /*!
                 Sets \a brush of the values that are drawn on top of this barset
             */
             void QBarSet::setLabelBrush(const QBrush &brush)
             {
                 if(d_ptr->m_labelBrush!=brush){
                     d_ptr->m_labelBrush = brush;
                     emit d_ptr->updatedBars();
                 }
             }
             /*!
                 Returns brush of the values that are drawn on top of this barset
             */
             QBrush QBarSet::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             /*!
                 Sets the \a font for values that are drawn on top of this barset
             */
             void QBarSet::setLabelFont(const QFont &font)
             {
                 if(d_ptr->m_labelFont!=font) {
                     d_ptr->m_labelFont = font;
                     emit d_ptr->updatedBars();
                 }
             }
             /*!
                 Returns the pen for values that are drawn on top of this set
             */
             QFont QBarSet::labelFont() const
             {
                 return d_ptr->m_labelFont;
             }
             /*!
                 Sets visibility of bar labels. If \a visible is true, labels are drawn on top of barsets.
             */
             void QBarSet::setLabelsVisible(bool visible)
             {
                 if(d_ptr->m_labelsVisible!=visible) {
                     d_ptr->m_labelsVisible = visible;
                     emit d_ptr->labelsVisibleChanged(visible);
                 }
             }
             /*!
                 Returns the visibility of values
             */
             bool QBarSet::labelsVisible() const
             {
                 return d_ptr->m_labelsVisible;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSetPrivate::QBarSetPrivate(const QString name, QBarSet *parent) : QObject(parent),
                 q_ptr(parent),
                 m_name(name),
                 m_labelsVisible(false)
             {
             }
             QBarSetPrivate::~QBarSetPrivate()
             {
             }
             #include "moc_qbarset.cpp"
             #include "moc_qbarset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.h +6 -10

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QBARSET_H
             #define QBARSET_H
             #include <qchartglobal.h>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSetPrivate;
             class QTCOMMERCIALCHART_EXPORT QBarSet : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString name READ name WRITE setName)
             public:
                 explicit QBarSet(const QString name, QObject *parent = 0);
                 virtual ~QBarSet();
                 void setName(const QString name);
                 QString name() const;
-            // TODO:
+                void append(const QPointF value);           // Appends bar with x-value
-            //    void append(const QPointF value);         // Appends bar with x-value
+                void append(const QList<QPointF> values);   // Same with list
-            //    void append(const QList<QPointF> value);  // Same with list
                 void append(const qreal value);             // TODO: change so, that count becomes x-value
+                void append(const QList<qreal> values);     // Append list of values. Using index as x-value
-            // TODO:
-            //    void append(const QList<qreal> values);   // Append list of values. Using index as x-value
                 QBarSet& operator << (const qreal &value);      // TODO: change implementations so, that count becomes x-value
-            // TODO:
+                QBarSet& operator << (const QPointF &value);    // Appends bar with x-value
-            //    QBarSet& operator << (const QPointF &value);  // Appends bar with x-value
                 void insert(const int index, const qreal value); // TODO: internal reindexing (what happens, if there are points with real x values?)
                 void remove(const int index);                    // TODO: internal reindexing (what happens, if there are points with real x values?)
                 void replace(const int index, const qreal value);
-                qreal at(const int index) const;
+                QPointF at(const int index) const;
-                qreal operator [] (int index) const;
+                QPointF operator [] (const int index) const;
                 int count() const;
                 qreal sum() const;
                 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 setLabelBrush(const QBrush &brush);
                 QBrush labelBrush() const;
                 void setLabelFont(const QFont &font);
                 QFont labelFont() const;
                 void setLabelsVisible(bool visible = true);
                 bool labelsVisible() const;
             Q_SIGNALS:
                 void clicked(QString category);
                 void hovered(bool status);
             private:
                 QScopedPointer<QBarSetPrivate> d_ptr;
                 Q_DISABLE_COPY(QBarSet)
                 friend class QBarSeries;
                 friend class BarLegendMarker;
                 friend class BarChartItem;
                 friend class QBarSeriesPrivate;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSET_H

src/barchart/qbarset_p.h +1 -2

             #ifndef QBARSET_P_H
             #define QBARSET_P_H
             #include "qbarset.h"
             #include <QMap>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSetPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QBarSetPrivate(const QString name, QBarSet *parent);
                 ~QBarSetPrivate();
             Q_SIGNALS:
                 void clicked(QString category);
                 void restructuredBars();
                 void updatedBars();
                 void labelsVisibleChanged(bool visible);
             public:
                 QBarSet * const q_ptr;
                 QString m_name;
-                QList<qreal> m_values;   // TODO: replace with map (category, value)
+                QList<QPointF> m_values;
-                QMap<QString, qreal> m_mappedValues;
                 QPen m_pen;
                 QBrush m_brush;
                 QPen m_labelPen;
                 QBrush m_labelBrush;
                 QFont m_labelFont;
                 bool m_labelsVisible;
                 friend class QBarSet;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSETPRIVATE_P_H

src/barchart/stackedbarchartitem.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "stackedbarchartitem_p.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "qbarset_p.h"
             #include "qbarseries_p.h"
             #include "qbarset.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             StackedBarChartItem::StackedBarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }
             QVector<QRectF> StackedBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accurancy
                 // Domain:
                 qreal range = m_domainMaxY - m_domainMinY;
                 qreal height = geometry().height();
                 qreal width = geometry().width();
                 qreal scale = (height / range);
                 qreal categotyCount = m_series->categoryCount();
                 qreal barWidth = width / (categotyCount * 2);
                 qreal xStep = width / categotyCount;
                 qreal xPos = xStep / 2 - barWidth / 2 + geometry().topLeft().x();
                 int itemIndex(0);
                 for (int category = 0; category < categotyCount; category++) {
                     qreal yPos = height + scale * m_domainMinY + geometry().topLeft().y();
                     for (int set=0; set < m_series->barsetCount(); set++) {
                         QBarSet* barSet = m_series->d_func()->barsetAt(set);
-                        qreal barHeight = barSet->at(category) * scale;
+                        qreal barHeight = barSet->at(category).y() * scale;
                         Bar* bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->pen());
                         bar->setBrush(barSet->brush());
                         QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         BarLabel* label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(barSet->at(category))) {
+                        if (!qFuzzyIsNull(barSet->at(category).y())) {
-                            label->setText(QString::number(barSet->at(category)));
+                            label->setText(QString::number(barSet->at(category).y()));
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->labelFont());
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 return layout;
             }
             #include "moc_stackedbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset.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 "chartdataset_p.h"
             #include "qaxis.h"
             #include "qaxis_p.h"
             #include "qabstractseries_p.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
                 m_axisX(new QAxis(this)),
                 m_axisY(new QAxis(this)),
                 m_domainIndex(0),
                 m_axisXInitialized(false),
                 m_axisYInitialized(false)
             {
                 //create main domain
                 Domain* domain = new Domain(m_axisY);
                 m_axisDomainMap.insert(m_axisY,domain);
                 QObject::connect(m_axisY->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                 QObject::connect(m_axisX->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool)));
                 QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),m_axisY->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                 QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),m_axisX->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
             }
             ChartDataSet::~ChartDataSet()
             {
                 removeAllSeries();
             }
             void ChartDataSet::addSeries(QAbstractSeries* series, QAxis *axisY)
             {
                 if(axisY==0) axisY = m_axisY;
                 QAxis* axis = m_seriesAxisMap.value(series);
                 if(axis) {
                     qWarning() << "Can not add series. Series already on the chart";
                     return;
                 }
                 series->setParent(this); // take ownership
                 axisY->setParent(this); // take ownership
                 Domain* domain = m_axisDomainMap.value(axisY);
                 if(!domain) {
                     domain = new Domain(axisY);
                     QObject::connect(axisY->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                     QObject::connect(axisX()->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int)));
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axisY->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                     //initialize
                     m_axisDomainMap.insert(axisY,domain);
                     emit axisAdded(axisY,domain);
                 }
                 if(!m_axisXInitialized){
                    m_axisXInitialized=true;
                    emit axisAdded(m_axisX,domain);
                 }
                 if(!m_axisYInitialized && axisY==m_axisY){
                    m_axisYInitialized=true;
                    emit axisAdded(m_axisY,domain);
                 }
                 series->d_ptr->scaleDomain(*domain);
-                if(series->type() == QAbstractSeries::SeriesTypeBar
+                if(series->type() == QAbstractSeries::SeriesTypeGroupedBar
                         || series->type() == QAbstractSeries::SeriesTypeStackedBar
                         || series->type() == QAbstractSeries::SeriesTypePercentBar) {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     setupCategories(barSeries);
                 }
                 if (series->type()== QAbstractSeries::SeriesTypePie && m_seriesAxisMap.count() == 0) {
                     axisX()->hide();
                     this->axisY()->hide();
                 }
                 m_seriesAxisMap.insert(series,axisY);
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 int key=0;
                 while (i.hasNext()) {
                     i.next();
                     if(i.key()!=key) {
                         break;
                     }
                     key++;
                 }
                 m_indexSeriesMap.insert(key,series);
                 series->d_ptr->m_dataset=this;
                 emit seriesAdded(series,domain);
             }
             QAxis* ChartDataSet::removeSeries(QAbstractSeries* series)
             {
                 QAxis* axis = m_seriesAxisMap.value(series);
                 if(!axis){
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                     return 0;
                 }
                 emit seriesRemoved(series);
                 m_seriesAxisMap.remove(series);
                 int key = seriesIndex(series);
                 Q_ASSERT(key!=-1);
                 m_indexSeriesMap.remove(key);
                 series->setParent(0);
                 series->d_ptr->m_dataset=0;
                 QList<QAxis*> axes =  m_seriesAxisMap.values();
                 int i = axes.indexOf(axis);
                 if(i==-1){
                     Domain* domain = m_axisDomainMap.take(axis);
                     emit axisRemoved(axis);
                     if(axis!=m_axisY){
                         axis->setParent(0);
                         delete domain;
                     }else{
                         m_axisYInitialized=false;
                         m_axisDomainMap.insert(m_axisY,domain);
                     }
                 }
                 if(m_seriesAxisMap.values().size()==0)
                 {
                     m_axisXInitialized=false;
                     emit axisRemoved(axisX());
                 }
                 return axis;
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QAbstractSeries*> series =  m_seriesAxisMap.keys();
                 QList<QAxis*> axes;
                 foreach(QAbstractSeries *s , series) {
                     QAxis* axis  = removeSeries(s);
                     if(axis==axisY()) continue;
                     int i = axes.indexOf(axis);
                     if(i==-1){
                         axes<<axis;
                     }
                 }
                 Q_ASSERT(m_seriesAxisMap.count()==0);
                 Q_ASSERT(m_axisDomainMap.count()==1);
                 qDeleteAll(series);
                 qDeleteAll(axes);
             }
             void ChartDataSet::setupCategories(QBarSeries* series)
             {
                QAxisCategories* categories = axisX()->categories();
                categories->clear();
                categories->insert(series->categories());
             }
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QAxis*, Domain*> i(m_axisDomainMap);
                 //main domain has to be the last one;
                 Domain *domain = m_axisDomainMap.value(axisY());
                 Q_ASSERT(domain);
                 while (i.hasNext()) {
                     i.next();
                     if(i.value()==domain) continue;
                     i.value()->zoomIn(rect,size);
                 }
                 domain->zoomIn(rect,size);
             }
             void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QAxis*, Domain*> i(m_axisDomainMap);
                 //main domain has to be the last one;
                 Domain *domain = m_axisDomainMap.value(axisY());
                 Q_ASSERT(domain);
                 while (i.hasNext()) {
                     i.next();
                     if(i.value()==domain) continue;
                     i.value()->zoomOut(rect,size);
                 }
                 domain->zoomOut(rect,size);
             }
             int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type)
             {
                 int count=0;
                 QMapIterator<QAbstractSeries*, QAxis*> i(m_seriesAxisMap);
                 while (i.hasNext()) {
                        i.next();
                        if(i.key()->type()==type) count++;
                 }
                 return count;
             }
             int ChartDataSet::seriesIndex(QAbstractSeries *series)
             {
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 while (i.hasNext()) {
                     i.next();
                     if (i.value() == series)
                         return i.key();
                 }
                 return -1;
             }
             QAxis* ChartDataSet::axisY(QAbstractSeries *series) const
             {
                 if(series == 0) return m_axisY;
                 return m_seriesAxisMap.value(series);
             }
             Domain* ChartDataSet::domain(QAbstractSeries *series) const
             {
             	QAxis* axis = m_seriesAxisMap.value(series);
             	if(axis){
             		return m_axisDomainMap.value(axis);
             	}else
             		return 0;
             }
             Domain* ChartDataSet::domain(QAxis* axis) const
             {
                 if(!axis || axis==axisX()) {
                     return  m_axisDomainMap.value(axisY());
                 }
                 else {
                     return m_axisDomainMap.value(axis);
                 }
             }
             void ChartDataSet::scrollDomain(int dx,int dy,const QSizeF& size)
             {
                 QMapIterator<QAxis*, Domain*> i( m_axisDomainMap);
                 //main domain has to be the last one;
                 Domain *domain = m_axisDomainMap.value(axisY());
                 while (i.hasNext()) {
                     i.next();
                     if(i.value()==domain) continue;
                     i.value()->move(dx,dy,size);
                 }
                 domain->move(dx,dy,size);
             }
             QList<QAbstractSeries*> ChartDataSet::series() const
             {
                 return m_seriesAxisMap.keys();
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qabstractseries.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 QABSTRACTSERIES_H
             #define QABSTRACTSERIES_H
             #include <qchartglobal.h>
             #include <QObject>
             #include <QPen>
             class QAbstractItemModel;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractSeriesPrivate;
             class QChart;
             //class QModelMapper;
             class QTCOMMERCIALCHART_EXPORT QAbstractSeries : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString name READ name WRITE setName)
                 Q_ENUMS(SeriesType)
             public:
                 enum SeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
+                    SeriesTypeGroupedBar,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline
                 };
             protected:
                 QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent = 0);
             public:
                 ~QAbstractSeries();
                 virtual SeriesType type() const = 0;
                 virtual void setModel(QAbstractItemModel *model) = 0;
                 QAbstractItemModel* model() const;
                 void setName(const QString& name);
                 QString name() const;
                 QChart* chart() const;
             protected:
                 QScopedPointer<QAbstractSeriesPrivate> d_ptr;
                 friend class ChartDataSet;
                 friend class ChartPresenter;
                 friend class QLegendPrivate;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

test/auto/qbarset/tst_qbarset.cpp +26 -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$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qbarset.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class tst_QBarSet : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qbarset_data();
                 void qbarset();
                 void name_data();
                 void name();
                 void append_data();
                 void append();
                 void appendOperator_data();
                 void appendOperator();
                 void insert_data();
                 void insert();
                 void remove_data();
                 void remove();
                 void replace_data();
                 void replace();
                 void at_data();
                 void at();
                 void atOperator_data();
                 void atOperator();
                 void count_data();
                 void count();
                 void sum_data();
                 void sum();
                 void setPen_data();
                 void setPen();
                 void setBrush_data();
                 void setBrush();
                 void setLabelPen_data();
                 void setLabelPen();
                 void setLabelBrush_data();
                 void setLabelBrush();
                 void setLabelFont_data();
                 void setLabelFont();
             private:
                 QBarSet* m_barset;
             };
             void tst_QBarSet::initTestCase()
             {
             }
             void tst_QBarSet::cleanupTestCase()
             {
             }
             void tst_QBarSet::init()
             {
                  m_barset = new QBarSet(QString("Name"));
             }
             void tst_QBarSet::cleanup()
             {
                 delete m_barset;
                 m_barset = 0;
             }
             void tst_QBarSet::qbarset_data()
             {
             }
             void tst_QBarSet::qbarset()
             {
                 QBarSet barset(QString("Name"));
                 QCOMPARE(barset.name(), QString("Name"));
                 QCOMPARE(barset.count(), 0);
                 QVERIFY(qFuzzyIsNull(barset.sum()));
             }
             void tst_QBarSet::name_data()
             {
                 QTest::addColumn<QString> ("name");
                 QTest::addColumn<QString> ("result");
                 QTest::newRow("name0") << QString("name0") << QString("name0");
                 QTest::newRow("name1") << QString("name1") << QString("name1");
             }
             void tst_QBarSet::name()
             {
                 QFETCH(QString, name);
                 QFETCH(QString, result);
                 m_barset->setName(name);
                 QCOMPARE(m_barset->name(), result);
             }
             void tst_QBarSet::append_data()
             {
                 QTest::addColumn<int> ("count");
                 QTest::newRow("0") << 0;
                 QTest::newRow("5") << 5;
                 QTest::newRow("100") << 100;
                 QTest::newRow("1000") << 1000;
             }
             void tst_QBarSet::append()
             {
                 QFETCH(int, count);
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 qreal sum(0.0);
                 qreal value(0.0);
                 for (int i=0; i<count; i++) {
                     m_barset->append(value);
-                    QCOMPARE(m_barset->at(i), value);
+                    QCOMPARE(m_barset->at(i).y(), value);
                     sum += value;
                     value += 1.0;
                 }
                 QCOMPARE(m_barset->count(), count);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), sum));
             }
             void tst_QBarSet::appendOperator_data()
             {
                 append_data();
             }
             void tst_QBarSet::appendOperator()
             {
                 QFETCH(int, count);
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 qreal sum(0.0);
                 qreal value(0.0);
                 for (int i=0; i<count; i++) {
                     *m_barset << value;
-                    QCOMPARE(m_barset->at(i), value);
+                    QCOMPARE(m_barset->at(i).y(), value);
                     sum += value;
                     value += 1.0;
                 }
                 QCOMPARE(m_barset->count(), count);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), sum));
             }
             void tst_QBarSet::insert_data()
             {
             }
             void tst_QBarSet::insert()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->insert(0, 1.0);       // 1.0
-                QCOMPARE(m_barset->at(0), 1.0);
+                QCOMPARE(m_barset->at(0).y(), 1.0);
                 QCOMPARE(m_barset->count(), 1);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), 1.0));
                 m_barset->insert(0, 2.0);       // 2.0 1.0
-                QCOMPARE(m_barset->at(0), 2.0);
+                QCOMPARE(m_barset->at(0).y(), 2.0);
-                QCOMPARE(m_barset->at(1), 1.0);
+                QCOMPARE(m_barset->at(1).y(), 1.0);
                 QCOMPARE(m_barset->count(), 2);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), 3.0));
                 m_barset->insert(1, 3.0);       // 2.0 3.0 1.0
-                QCOMPARE(m_barset->at(1), 3.0);
+                QCOMPARE(m_barset->at(1).y(), 3.0);
-                QCOMPARE(m_barset->at(0), 2.0);
+                QCOMPARE(m_barset->at(0).y(), 2.0);
-                QCOMPARE(m_barset->at(2), 1.0);
+                QCOMPARE(m_barset->at(2).y(), 1.0);
                 QCOMPARE(m_barset->count(), 3);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), 6.0));
             }
             void tst_QBarSet::remove_data()
             {
             }
             void tst_QBarSet::remove()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->count(), 4);
                 QCOMPARE(m_barset->sum(), 10.0);
                 m_barset->remove(2);                // 1.0 2.0 4.0
-                QCOMPARE(m_barset->at(0), 1.0);
+                QCOMPARE(m_barset->at(0).y(), 1.0);
-                QCOMPARE(m_barset->at(1), 2.0);
+                QCOMPARE(m_barset->at(1).y(), 2.0);
-                QCOMPARE(m_barset->at(2), 4.0);
+                QCOMPARE(m_barset->at(2).y(), 4.0);
                 QCOMPARE(m_barset->count(), 3);
                 QCOMPARE(m_barset->sum(), 7.0);
                 m_barset->remove(0);                // 2.0 4.0
-                QCOMPARE(m_barset->at(0), 2.0);
+                QCOMPARE(m_barset->at(0).y(), 2.0);
-                QCOMPARE(m_barset->at(1), 4.0);
+                QCOMPARE(m_barset->at(1).y(), 4.0);
                 QCOMPARE(m_barset->count(), 2);
                 QCOMPARE(m_barset->sum(), 6.0);
             }
             void tst_QBarSet::replace_data()
             {
             }
             void tst_QBarSet::replace()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->count(), 4);
                 QCOMPARE(m_barset->sum(), 10.0);
                 m_barset->replace(0, 5.0);          // 5.0 2.0 3.0 4.0
                 QCOMPARE(m_barset->count(), 4);
                 QCOMPARE(m_barset->sum(), 14.0);
-                QCOMPARE(m_barset->at(0), 5.0);
+                QCOMPARE(m_barset->at(0).y(), 5.0);
                 m_barset->replace(3, 6.0);
                 QCOMPARE(m_barset->count(), 4);     // 5.0 2.0 3.0 6.0
                 QCOMPARE(m_barset->sum(), 16.0);
-                QCOMPARE(m_barset->at(0), 5.0);
+                QCOMPARE(m_barset->at(0).y(), 5.0);
-                QCOMPARE(m_barset->at(1), 2.0);
+                QCOMPARE(m_barset->at(1).y(), 2.0);
-                QCOMPARE(m_barset->at(2), 3.0);
+                QCOMPARE(m_barset->at(2).y(), 3.0);
-                QCOMPARE(m_barset->at(3), 6.0);
+                QCOMPARE(m_barset->at(3).y(), 6.0);
             }
             void tst_QBarSet::at_data()
             {
             }
             void tst_QBarSet::at()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
-                QCOMPARE(m_barset->at(0), 1.0);
+                QCOMPARE(m_barset->at(0).y(), 1.0);
-                QCOMPARE(m_barset->at(1), 2.0);
+                QCOMPARE(m_barset->at(1).y(), 2.0);
-                QCOMPARE(m_barset->at(2), 3.0);
+                QCOMPARE(m_barset->at(2).y(), 3.0);
-                QCOMPARE(m_barset->at(3), 4.0);
+                QCOMPARE(m_barset->at(3).y(), 4.0);
             }
             void tst_QBarSet::atOperator_data()
             {
             }
             void tst_QBarSet::atOperator()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
-                QCOMPARE(m_barset->operator [](0), 1.0);
+                QCOMPARE(m_barset->operator [](0).y(), 1.0);
-                QCOMPARE(m_barset->operator [](1), 2.0);
+                QCOMPARE(m_barset->operator [](1).y(), 2.0);
-                QCOMPARE(m_barset->operator [](2), 3.0);
+                QCOMPARE(m_barset->operator [](2).y(), 3.0);
-                QCOMPARE(m_barset->operator [](3), 4.0);
+                QCOMPARE(m_barset->operator [](3).y(), 4.0);
             }
             void tst_QBarSet::count_data()
             {
             }
             void tst_QBarSet::count()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 QCOMPARE(m_barset->count(),1);
                 m_barset->append(2.0);
                 QCOMPARE(m_barset->count(),2);
                 m_barset->append(3.0);
                 QCOMPARE(m_barset->count(),3);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->count(),4);
             }
             void tst_QBarSet::sum_data()
             {
             }
             void tst_QBarSet::sum()
             {
                 QCOMPARE(m_barset->count(), 0);
                 QVERIFY(qFuzzyIsNull(m_barset->sum()));
                 m_barset->append(1.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(),1.0));
                 m_barset->append(2.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(),3.0));
                 m_barset->append(3.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(),6.0));
                 m_barset->append(4.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(),10.0));
             }
             void tst_QBarSet::setPen_data()
             {
             }
             void tst_QBarSet::setPen()
             {
                 QVERIFY(m_barset->pen() == QPen());
                 QPen pen;
                 pen.setColor(QColor(128,128,128,128));
                 m_barset->setPen(pen);
                 QVERIFY(m_barset->pen() == pen);
             }
             void tst_QBarSet::setBrush_data()
             {
             }
             void tst_QBarSet::setBrush()
             {
                 QVERIFY(m_barset->brush() == QBrush());
                 QBrush brush;
                 brush.setColor(QColor(128,128,128,128));
                 m_barset->setBrush(brush);
                 QVERIFY(m_barset->brush() == brush);
             }
             void tst_QBarSet::setLabelPen_data()
             {
             }
             void tst_QBarSet::setLabelPen()
             {
                 QVERIFY(m_barset->labelPen() == QPen());
                 QPen pen;
                 pen.setColor(QColor(128,128,128,128));
                 m_barset->setLabelPen(pen);
                 QVERIFY(m_barset->labelPen() == pen);
             }
             void tst_QBarSet::setLabelBrush_data()
             {
             }
             void tst_QBarSet::setLabelBrush()
             {
                 QVERIFY(m_barset->labelBrush() == QBrush());
                 QBrush brush;
                 brush.setColor(QColor(128,128,128,128));
                 m_barset->setLabelBrush(brush);
                 QVERIFY(m_barset->labelBrush() == brush);
             }
             void tst_QBarSet::setLabelFont_data()
             {
             }
             void tst_QBarSet::setLabelFont()
             {
                 QVERIFY(m_barset->labelFont() == QFont());
                 QFont font;
                 font.setBold(true);
                 font.setItalic(true);
                 m_barset->setLabelFont(font);
                 QVERIFY(m_barset->labelFont() == font);
             }
             QTEST_MAIN(tst_QBarSet)
             #include "tst_qbarset.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