HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r101:5389336c8e0d

percent bar chart

sauimone -

r101:5389336c8e0d

parent child

Context file:

r101:5389336c8e0d

Collapse all files

example/percentbarchart/chartwidget.cpp created 644 +6 0

@@ -0,0 +1,6
	1	#include "chartwidget.h"
	2
	3	ChartWidget::ChartWidget(QWidget *parent) :
	4	QChartView(parent)
	5	{
	6	}

example/percentbarchart/chartwidget.h created 644 +21 0

@@ -0,0 +1,21
	1	#ifndef CHARTWIDGET_H
	2	#define CHARTWIDGET_H
	3
	4	#include <qchartview.h>
	5
	6	QTCOMMERCIALCHART_USE_NAMESPACE
	7
	8
	9	class ChartWidget : public QChartView
	10	{
	11	Q_OBJECT
	12	public:
	13	explicit ChartWidget(QWidget *parent = 0);
	14
	15	signals:
	16
	17	public slots:
	18
	19	};
	20
	21	#endif // CHARTWIDGET_H

example/percentbarchart/main.cpp created 644 +88 0

@@ -0,0 +1,88
	1	#include <QApplication>
	2	#include <QMainWindow>
	3	#include <QStandardItemModel>
	4	#include <percentbarchartseries.h>
	5	#include "chartwidget.h"
	6
	7	QTCOMMERCIALCHART_USE_NAMESPACE
	8
	9	int main(int argc, char *argv[])
	10	{
	11	QApplication a(argc, argv);
	12	QMainWindow window;
	13
	14	PercentBarChartSeries* series0 = new PercentBarChartSeries();
	15
	16	// Create some test data to chart
	17	QStandardItemModel dataModel(5,10);
	18	QModelIndex index;
	19	index = dataModel.index(0,0);
	20
	21	// Series 0
	22	dataModel.setData(dataModel.index(0,0),1);
	23	dataModel.setData(dataModel.index(0,1),2);
	24	dataModel.setData(dataModel.index(0,2),3);
	25	dataModel.setData(dataModel.index(0,3),4);
	26	dataModel.setData(dataModel.index(0,4),5);
	27	dataModel.setData(dataModel.index(0,5),6);
	28	dataModel.setData(dataModel.index(0,6),7);
	29	dataModel.setData(dataModel.index(0,7),8);
	30	dataModel.setData(dataModel.index(0,8),9);
	31	dataModel.setData(dataModel.index(0,9),10);
	32
	33	// Series 1, some other items missing
	34	dataModel.setData(dataModel.index(1,0),5);
	35	dataModel.setData(dataModel.index(1,3),4);
	36	dataModel.setData(dataModel.index(1,5),7);
	37	dataModel.setData(dataModel.index(1,6),8);
	38	dataModel.setData(dataModel.index(1,8),9);
	39	dataModel.setData(dataModel.index(1,9),9);
	40
	41	// Series 2
	42	dataModel.setData(dataModel.index(2,0),3);
	43	dataModel.setData(dataModel.index(2,1),5);
	44	dataModel.setData(dataModel.index(2,2),8);
	45	dataModel.setData(dataModel.index(2,3),13);
	46	dataModel.setData(dataModel.index(2,4),8);
	47	dataModel.setData(dataModel.index(2,5),5);
	48	dataModel.setData(dataModel.index(2,6),3);
	49	dataModel.setData(dataModel.index(2,7),2);
	50	dataModel.setData(dataModel.index(2,8),1);
	51	dataModel.setData(dataModel.index(2,9),1);
	52
	53	// Series 3
	54	dataModel.setData(dataModel.index(3,0),5);
	55	dataModel.setData(dataModel.index(3,1),6);
	56	dataModel.setData(dataModel.index(3,2),7);
	57	dataModel.setData(dataModel.index(3,3),3);
	58	dataModel.setData(dataModel.index(3,4),4);
	59	dataModel.setData(dataModel.index(3,5),5);
	60	dataModel.setData(dataModel.index(3,6),8);
	61	dataModel.setData(dataModel.index(3,7),9);
	62	dataModel.setData(dataModel.index(3,8),10);
	63	dataModel.setData(dataModel.index(3,9),5);
	64
	65	// Series 4
	66	dataModel.setData(dataModel.index(4,0),9);
	67	dataModel.setData(dataModel.index(4,1),7);
	68	dataModel.setData(dataModel.index(4,2),5);
	69	dataModel.setData(dataModel.index(4,3),3);
	70	dataModel.setData(dataModel.index(4,4),1);
	71	dataModel.setData(dataModel.index(4,5),2);
	72	dataModel.setData(dataModel.index(4,6),4);
	73	dataModel.setData(dataModel.index(4,7),6);
	74	dataModel.setData(dataModel.index(4,8),8);
	75	dataModel.setData(dataModel.index(4,9),10);
	76
	77	series0->setData(&dataModel);
	78
	79	ChartWidget* chartWidget = new ChartWidget(&window);
	80	chartWidget->addSeries(series0);
	81
	82	window.setCentralWidget(chartWidget);
	83	window.resize(400, 300);
	84	window.show();
	85
	86	return a.exec();
	87	}
	88

example/percentbarchart/percentbarchart.pro created 644 +17 0

@@ -0,0 +1,17
	1	!include( ../../common.pri ) {
	2	error( "Couldn't find the common.pri file!" )
	3	}
	4
	5	!include( ../../integrated.pri ) {
	6	error( "Couldn't find the integrated.pri file !")
	7	}
	8
	9	TARGET = percentbarchart
	10	TEMPLATE = app
	11	QT += core gui
	12	SOURCES += main.cpp \
	13	chartwidget.cpp
	14
	15	HEADERS += \
	16	chartwidget.h
	17

src/barchart/percentbarchartseries.cpp created 644 +110 0

@@ -0,0 +1,110
	1	#include "percentbarchartseries.h"
	2
	3	#include <limits.h>
	4	#include <QDebug>
	5	#include "percentbarchartseries.h"
	6
	7	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	8
	9	PercentBarChartSeries::PercentBarChartSeries(QObject *parent) :
	10	QChartSeries(parent)
	11	{
	12	}
	13
	14	bool PercentBarChartSeries::setData(QAbstractItemModel* model)
	15	{
	16	mModel = model;
	17	}
	18
	19	int PercentBarChartSeries::min()
	20	{
	21	Q_ASSERT(mModel->rowCount() > 0);
	22	Q_ASSERT(mModel->columnCount() > 0);
	23
	24	// TODO: make min and max members and update them when data changes.
	25	// This is slower since they are checked every time, even if data is same since previous call.
	26	int min = INT_MAX;
	27
	28	for (int i=0; i <mModel->rowCount(); i++) {
	29	for(int j=0; j<mModel->columnCount(); j++) {
	30	int temp = mModel->data(mModel->index(i,j)).toInt();
	31	if (temp < min) {
	32	min = temp;
	33	}
	34	}
	35	}
	36	return min;
	37	}
	38
	39	int PercentBarChartSeries::max()
	40	{
	41	Q_ASSERT(mModel->rowCount() > 0);
	42	Q_ASSERT(mModel->columnCount() > 0);
	43
	44	// TODO: make min and max members and update them when data changes.
	45	// This is slower since they are checked every time, even if data is same since previous call.
	46	int max = INT_MIN;
	47
	48	for (int i=0; i <mModel->rowCount(); i++) {
	49	for(int j=0; j<mModel->columnCount(); j++) {
	50	int temp = mModel->data(mModel->index(i,j)).toInt();
	51	if (temp > max) {
	52	max = temp;
	53	}
	54	}
	55	}
	56	return max;
	57	}
	58
	59	int PercentBarChartSeries::maxColumnSum()
	60	{
	61	Q_ASSERT(mModel->rowCount() > 0);
	62	Q_ASSERT(mModel->columnCount() > 0);
	63
	64	int max = INT_MIN;
	65
	66	for (int col=0; col <mModel->columnCount(); col++) {
	67	int sum = columnSum(col);
	68	if (sum > max) {
	69	max = sum;
	70	}
	71	}
	72	return max;
	73	}
	74
	75	int PercentBarChartSeries::countRows()
	76	{
	77	return mModel->rowCount();
	78	}
	79
	80	int PercentBarChartSeries::countColumns()
	81	{
	82	return mModel->columnCount();
	83	}
	84
	85	int PercentBarChartSeries::countTotalItems()
	86	{
	87	return mModel->rowCount() * mModel->columnCount();
	88	}
	89
	90	int PercentBarChartSeries::valueAt(int row, int column)
	91	{
	92	QModelIndex index = mModel->index(row,column);
	93	return mModel->data(index).toInt();
	94	}
	95
	96	int PercentBarChartSeries::columnSum(int column)
	97	{
	98	int sum(0);
	99	int count = mModel->rowCount();
	100
	101	for (int row = 0; row < count; row++) {
	102	sum += mModel->data(mModel->index(row,column)).toInt();
	103	}
	104	return sum;
	105	}
	106
	107	#include "moc_percentbarchartseries.cpp"
	108
	109	QTCOMMERCIALCHART_END_NAMESPACE
	110

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

@@ -0,0 +1,47
	1	#ifndef PERCENTBARCHARTSERIES_H
	2	#define PERCENTBARCHARTSERIES_H
	3
	4	#include <QList>
	5	#include <QAbstractItemModel>
	6	#include "qchartseries.h"
	7
	8	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	9
	10	class PercentBarGroup;
	11
	12	class QTCOMMERCIALCHART_EXPORT PercentBarChartSeries : public QChartSeries
	13	{
	14	Q_OBJECT
	15	public:
	16	PercentBarChartSeries(QObject* parent=0);
	17
	18	// from QChartSeries
	19	virtual QChartSeriesType type() const { return QChartSeries::SeriesTypePercentBar; }
	20
	21	// TODO: Better data model?
	22	virtual bool setData(QAbstractItemModel* model);
	23
	24	// Methods to find out minimum and maximum values of data
	25	int min();
	26	int max();
	27	int maxColumnSum(); // returns maximum sum of items in all columns.
	28
	29	int countRows();
	30	int countColumns();
	31	int countTotalItems();
	32	int valueAt(int row, int column);
	33
	34	int columnSum(int column);
	35
	36	public Q_SLOTS:
	37
	38	private:
	39
	40	QAbstractItemModel* mModel;
	41	PercentBarGroup* mPercentBarGroup;
	42	};
	43
	44	QTCOMMERCIALCHART_END_NAMESPACE
	45
	46
	47	#endif // PERCENTBARCHARTSERIES_H

src/barchart/percentbargroup.cpp created 644 +136 0

@@ -0,0 +1,136
	1	#include "percentbargroup.h"
	2
	3	#include "stackedbargroup.h"
	4	#include "bar.h"
	5	#include <QDebug>
	6
	7	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	8
	9	StackedBarGroup::StackedBarGroup(StackedBarChartSeries& series, QGraphicsItem *parent) :
	10	ChartItem(parent)
	11	,mSeries(series)
	12	,mLayoutSet(false)
	13	,mLayoutDirty(true)
	14	,mBarDefaultWidth(20) // TODO: remove hard coding, when we have layout code ready
	15	{
	16	dataChanged();
	17	}
	18
	19
	20	void StackedBarGroup::setSize(const QSize& size)
	21	{
	22	qDebug() << "StackedBarGroup::setSize";
	23	mWidth = size.width();
	24	mHeight = size.height();
	25	layoutChanged();
	26	mLayoutSet = true;
	27	}
	28
	29	void StackedBarGroup::setPlotDomain(const PlotDomain& data)
	30	{
	31	qDebug() << "StackedBarGroup::setPlotDomain";
	32	// TODO:
	33	}
	34
	35	void StackedBarGroup::setBarWidth( int w )
	36	{
	37	mBarDefaultWidth = w;
	38	}
	39
	40	int StackedBarGroup::addColor( QColor color )
	41	{
	42	int colorIndex = mColors.count();
	43	mColors.append(color);
	44	return colorIndex;
	45	}
	46
	47	void StackedBarGroup::resetColors()
	48	{
	49	mColors.clear();
	50	}
	51
	52	void StackedBarGroup::paint(QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget)
	53	{
	54	if (!mLayoutSet) {
	55	qDebug() << "QBarChart::paint called without layout set. Aborting.";
	56	return;
	57	}
	58	if (mLayoutDirty) {
	59	// Layout or data has changed. Need to redraw.
	60	foreach(QGraphicsItem* i, childItems()) {
	61	i->paint(painter,option,widget);
	62	}
	63	}
	64	}
	65
	66	QRectF StackedBarGroup::boundingRect() const
	67	{
	68	return QRectF(0,0,mWidth,mHeight);
	69	}
	70
	71
	72	void StackedBarGroup::dataChanged()
	73	{
	74	qDebug() << "QBarChart::dataChanged mSeries";
	75
	76	// Find out maximum and minimum of all series
	77	mMax = mSeries.max();
	78	mMin = mSeries.min();
	79
	80	// Delete old bars
	81	// Is this correct way to delete childItems?
	82	foreach (QGraphicsItem* item, childItems()) {
	83	delete item;
	84	}
	85
	86	// Create new graphic items for bars
	87	int totalItems = mSeries.countTotalItems();
	88	for (int i=0; i<totalItems; i++) {
	89	Bar *bar = new Bar(this);
	90	childItems().append(bar);
	91	}
	92
	93	mLayoutDirty = true;
	94	}
	95
	96	void StackedBarGroup::layoutChanged()
	97	{
	98	// Scale bars to new layout
	99	// Layout for bars:
	100	if (mSeries.countRows() <= 0) {
	101	// Nothing to do.
	102	return;
	103	}
	104
	105	// TODO: better way to auto-layout
	106	// Use reals for accurancy (we might get some compiler warnings... :)
	107	qreal maxSum = mSeries.maxColumnSum();
	108	qreal h = mHeight;
	109	qreal scale = (h / maxSum);
	110
	111	int count = mSeries.countColumns();
	112	int itemIndex(0);
	113	qreal tW = mWidth;
	114	qreal tC = count+1;
	115	qreal xStep = (tW/tC);
	116	qreal xPos = ((tW/tC) + mBarDefaultWidth / 2);
	117
	118	for (int column = 0; column < mSeries.countColumns(); column++) {
	119	qreal yPos = h;
	120	for (int row=0; row < mSeries.countRows(); row++) {
	121	qreal barHeight = mSeries.valueAt(row, column) * scale;
	122	Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
	123
	124	// TODO: width settable per bar?
	125	bar->resize(mBarDefaultWidth, barHeight);
	126	bar->setColor(mColors.at(row));
	127	bar->setPos(xPos, yPos);
	128	itemIndex++;
	129	yPos -= barHeight;
	130	}
	131	xPos += xStep;
	132	}
	133	mLayoutDirty = true;
	134	}
	135
	136	QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/percentbargroup.h created 644 +55 0

@@ -0,0 +1,55
	1	#ifndef PERCENTBARGROUP_H
	2	#define PERCENTBARGROUP_H
	3
	4	#include "chartitem_p.h"
	5	#include "bar.h"
	6	#include "percentbarchartseries.h"
	7
	8	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	9
	10	class PercentBarGroup : public ChartItem
	11	{
	12	public:
	13	PercentBarGroup(PercentBarChartSeries& series, QGraphicsItem *parent = 0);
	14
	15	// From ChartItem
	16	virtual void setSize(const QSize& size);
	17	virtual void setPlotDomain(const PlotDomain& data);
	18
	19	// Layout "api"
	20	void setPos(qreal x, qreal y);
	21	void setBarWidth( int w ); // Default width for each bar
	22
	23	int addColor( QColor color );
	24	void resetColors();
	25
	26	// From QGraphicsItem
	27	void paint(QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget);
	28	QRectF boundingRect() const;
	29
	30	private:
	31
	32	void dataChanged(); // data of series has changed -> need to recalculate bar sizes
	33	void layoutChanged(); // layout has changed -> need to recalculate bar sizes
	34
	35	private:
	36
	37	// Data
	38	PercentBarChartSeries& mSeries;
	39	int mMin; // Min and max values of data. (updated when data is changed, used when drawing)
	40	int mMax;
	41
	42	int mHeight; // Layout spesific
	43	int mWidth;
	44	int mBarDefaultWidth;
	45
	46	bool mLayoutSet; // True, if component has been laid out.
	47	bool mLayoutDirty;
	48
	49	QList<QColor> mColors; // List of colors for series for now
	50
	51	};
	52
	53	QTCOMMERCIALCHART_END_NAMESPACE
	54
	55	#endif // PERCENTBARGROUP_H

src/barchart/bargroup.cpp +2 -22

             #include "bargroup.h"
             #include "bar.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarGroup::BarGroup(BarChartSeries& series, QGraphicsItem *parent) :
               ChartItem(parent)
               ,mSeries(series)
               ,mLayoutSet(false)
               ,mLayoutDirty(true)
               ,mBarDefaultWidth(10)
             {
                 dataChanged();
             }
             void BarGroup::setSize(const QSize& size)
             {
                 qDebug() << "BarGroup::setSize";
                 mWidth = size.width();
                 mHeight = size.height();
                 layoutChanged();
                 mLayoutSet = true;
             }
             void BarGroup::setPlotDomain(const PlotDomain& data)
             {
                 qDebug() << "BarGroup::setPlotDomain";
                 // TODO:
+                mPlotDomain = data;
             }
             void BarGroup::setBarWidth( int w )
             {
                 mBarDefaultWidth = w;
             }
             int BarGroup::addColor( QColor color )
             {
                 int colorIndex = mColors.count();
                 mColors.append(color);
                 return colorIndex;
             }
             void BarGroup::resetColors()
             {
                 mColors.clear();
             }
             void BarGroup::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (!mLayoutSet) {
                     qDebug() << "QBarChart::paint called without layout set. Aborting.";
                     return;
                 }
                 if (mLayoutDirty) {
                     // Layout or data has changed. Need to redraw.
                     foreach(QGraphicsItem* i, childItems()) {
                         i->paint(painter,option,widget);
                     }
                 }
             }
             QRectF BarGroup::boundingRect() const
             {
                 return QRectF(0,0,mWidth,mHeight);
             }
             void BarGroup::dataChanged()
             {
                 qDebug() << "QBarChart::dataChanged mSeries";
                 // Find out maximum and minimum of all series
                 mMax = mSeries.max();
                 mMin = mSeries.min();
                 // Delete old bars
                 // Is this correct way to delete childItems?
                 foreach (QGraphicsItem* item, childItems()) {
                     delete item;
                 }
                 // Create new graphic items for bars
                 int totalItems = mSeries.countTotalItems();
                 for (int i=0; i<totalItems; i++) {
                     Bar *bar = new Bar(this);
                     childItems().append(bar);
                 }
                 mLayoutDirty = true;
             }
             void BarGroup::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries.countRows() <= 0) {
                     // Nothing to do.
                     return;
                 }
-                // TODO: better way to auto-layout
+                // TODO: better way to auto-layout?
                 // Use reals for accurancy (we might get some compiler warnings... :)
                 int columnCount = mSeries.countColumns();
                 int rowCount = mSeries.countRows();
                 qreal tW = mWidth;
                 qreal tH = mHeight;
                 qreal tM = mMax;
                 qreal scale = (tH/tM);
                 qreal tC = columnCount+1;
                 qreal xStepPerSeries = (tW/tC);
-                //qint startPos = (mWidth / (count+1)) - mSeries.countSeries() * mBarDefaultWidth /2;
-            //    qDebug() << "XPOS:" << xPos;
                 qDebug() << "XSTEP:" << xStepPerSeries;
-                // TODO: Correct the calculations...
                 // Scaling.
                 int itemIndex(0);
                 for (int column=0; column < columnCount; column++) {
                     qreal xPos = xStepPerSeries * column + ((tW + mBarDefaultWidth*rowCount)/(columnCount*2));
-                    qDebug() << "XPOS:" << xPos;
                     for (int row = 0; row < rowCount; row++) {
                         qreal barHeight = mSeries.valueAt(row, column) * scale;
                         Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
                         // TODO: width settable per bar?
                         bar->resize(mBarDefaultWidth, barHeight);
                         bar->setColor(mColors.at(row));
                         bar->setPos(xPos, mHeight); // item*posStep+startPos + series * mBarDefaultWidth, mHeight);
                         itemIndex++;
                         xPos += mBarDefaultWidth;
                     }
                 }
-                /*
-                for (int series = 0; series < mSeries.countRows(); series++) {
-                    for (int item=0; item < mSeries.countColumns(); item++) {
-                        qreal barHeight = mSeries.valueAt(series, item) * scale;
-                        Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
-                        // TODO: width settable per bar?
-                        bar->resize(mBarDefaultWidth, barHeight);
-                        bar->setColor(mColors.at(series));
-                        bar->setPos(xPos, mHeight); // item*posStep+startPos + series * mBarDefaultWidth, mHeight);
-                        itemIndex++;
-                        xPos += mBarDefaultWidth;
-                    xPos = xStepPerSeries * series;
-                */
                 mLayoutDirty = true;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/bargroup.h +2 0

             #ifndef QBARGROUP_H
             #define QBARGROUP_H
             #include "chartitem_p.h"
             #include "bar.h"
             #include "barchartseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class BarGroup : public ChartItem
             {
             public:
                 explicit BarGroup(BarChartSeries& series, QGraphicsItem *parent = 0);
                 // From ChartItem
                 virtual void setSize(const QSize& size);
                 virtual void setPlotDomain(const PlotDomain& data);
                 // Layout "api"
                 void setPos(qreal x, qreal y);
                 void setBarWidth( int w );          // Default width for each bar
                 int addColor( QColor color );
                 void resetColors();
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
             private:
                 void dataChanged();     // data of series has changed -> need to recalculate bar sizes
                 void layoutChanged();   // layout has changed -> need to recalculate bar sizes
             private:
                 // Data
                 BarChartSeries& mSeries;
                 int mMin;                                   // Min and max values of data. (updated when data is changed, used when drawing)
                 int mMax;
                 int mHeight;        // Layout spesific
                 int mWidth;
                 int mBarDefaultWidth;
                 bool mLayoutSet;    // True, if component has been laid out.
                 bool mLayoutDirty;
                 QList<QColor> mColors;  // List of colors for series for now
+                PlotDomain mPlotDomain;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARGROUP_H

src/barchart/stackedbargroup.cpp +16 -17

-            #include "stackedbargroup.h"
+            #include "percentbargroup.h"
             #include "bar.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            StackedBarGroup::StackedBarGroup(StackedBarChartSeries& series, QGraphicsItem *parent) :
+            PercentBarGroup::PercentBarGroup(PercentBarChartSeries& series, QGraphicsItem *parent) :
               ChartItem(parent)
               ,mSeries(series)
               ,mLayoutSet(false)
               ,mLayoutDirty(true)
               ,mBarDefaultWidth(20) // TODO: remove hard coding, when we have layout code ready
             {
                 dataChanged();
             }
-            void StackedBarGroup::setSize(const QSize& size)
+            void PercentBarGroup::setSize(const QSize& size)
             {
-                qDebug() << "StackedBarGroup::setSize";
+                qDebug() << "PercentBarGroup::setSize";
                 mWidth = size.width();
                 mHeight = size.height();
                 layoutChanged();
                 mLayoutSet = true;
             }
-            void StackedBarGroup::setPlotDomain(const PlotDomain& data)
+            void PercentBarGroup::setPlotDomain(const PlotDomain& data)
             {
-                qDebug() << "StackedBarGroup::setPlotDomain";
+                qDebug() << "PercentBarGroup::setPlotDomain";
                 // TODO:
             }
-            void StackedBarGroup::setBarWidth( int w )
+            void PercentBarGroup::setBarWidth( int w )
             {
                 mBarDefaultWidth = w;
             }
-            int StackedBarGroup::addColor( QColor color )
+            int PercentBarGroup::addColor( QColor color )
             {
                 int colorIndex = mColors.count();
                 mColors.append(color);
                 return colorIndex;
             }
-            void StackedBarGroup::resetColors()
+            void PercentBarGroup::resetColors()
             {
                 mColors.clear();
             }
-            void StackedBarGroup::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+            void PercentBarGroup::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (!mLayoutSet) {
                     qDebug() << "QBarChart::paint called without layout set. Aborting.";
                     return;
                 }
                 if (mLayoutDirty) {
                     // Layout or data has changed. Need to redraw.
                     foreach(QGraphicsItem* i, childItems()) {
                         i->paint(painter,option,widget);
                     }
                 }
             }
-            QRectF StackedBarGroup::boundingRect() const
+            QRectF PercentBarGroup::boundingRect() const
             {
                 return QRectF(0,0,mWidth,mHeight);
             }
-            void StackedBarGroup::dataChanged()
+            void PercentBarGroup::dataChanged()
             {
                 qDebug() << "QBarChart::dataChanged mSeries";
                 // Find out maximum and minimum of all series
                 mMax = mSeries.max();
                 mMin = mSeries.min();
                 // Delete old bars
                 // Is this correct way to delete childItems?
                 foreach (QGraphicsItem* item, childItems()) {
                     delete item;
                 }
                 // Create new graphic items for bars
                 int totalItems = mSeries.countTotalItems();
                 for (int i=0; i<totalItems; i++) {
                     Bar *bar = new Bar(this);
                     childItems().append(bar);
                 }
                 mLayoutDirty = true;
             }
-            void StackedBarGroup::layoutChanged()
+            void PercentBarGroup::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries.countRows() <= 0) {
                     // Nothing to do.
                     return;
                 }
                 // TODO: better way to auto-layout
                 // Use reals for accurancy (we might get some compiler warnings... :)
-                qreal maxSum = mSeries.maxColumnSum();
-                qreal h = mHeight;
-                qreal scale = (h / maxSum);
                 int count = mSeries.countColumns();
                 int itemIndex(0);
                 qreal tW = mWidth;
                 qreal tC = count+1;
                 qreal xStep = (tW/tC);
                 qreal xPos = ((tW/tC) + mBarDefaultWidth / 2);
                 for (int column = 0; column < mSeries.countColumns(); column++) {
+                    qreal colSum = mSeries.columnSum(column);
+                    qreal h = mHeight;
+                    qreal scale = (h / colSum);
                     qreal yPos = h;
                     for (int row=0; row < mSeries.countRows(); row++) {
                         qreal barHeight = mSeries.valueAt(row, column) * scale;
                         Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
                         // TODO: width settable per bar?
                         bar->resize(mBarDefaultWidth, barHeight);
                         bar->setColor(mColors.at(row));
                         bar->setPos(xPos, yPos);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 mLayoutDirty = true;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.cpp +23 0

             #include "qchart.h"
             #include "qchartseries.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "qpieseries.h"
             #include "qxychartseries.h"
             #include "qchartaxis.h"
             #include "barchartseries.h"
             #include "bargroup.h"
             #include "stackedbarchartseries.h"
             #include "stackedbargroup.h"
+            #include "percentbarchartseries.h"
+            #include "percentbargroup.h"
             #include "xylinechartitem_p.h"
             #include "plotdomain_p.h"
             #include "axisitem_p.h"
             #include <QGraphicsScene>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChart::QChart(QGraphicsObject* parent) : QGraphicsObject(parent),
                 m_backgroundItem(0),
                 m_titleItem(0),
                 m_axisXItem(new AxisItem(AxisItem::X_AXIS,this)),
                 m_plotDataIndex(0),
                 m_marginSize(0)
             {
                 // TODO: the default theme?
                 setTheme(QChart::ChartThemeDefault);
                 PlotDomain domain;
                 m_plotDomainList<<domain;
                 m_axisYItem << new AxisItem(AxisItem::Y_AXIS,this);
                 m_chartItems<<m_axisXItem;
                 m_chartItems<<m_axisYItem.at(0);
             }
             QChart::~QChart(){}
             QRectF QChart::boundingRect() const
             {
                 return m_rect;
             }
             void QChart::addSeries(QChartSeries* series)
             {
                 // TODO: we should check the series not already added
                 m_chartSeries << series;
                 switch(series->type())
                 {
                 case QChartSeries::SeriesTypeLine: {
                     QXYChartSeries* xyseries = static_cast<QXYChartSeries*>(series);
                     // Use color defined by theme in case the series does not define a custom color
                     if (!xyseries->pen().color().isValid() && m_themeColors.count()) //TODO: wtf
                         xyseries->setPen(nextColor());
                     m_plotDataIndex = 0 ;
                     m_plotDomainList.resize(1);
                     PlotDomain& domain = m_plotDomainList[m_plotDataIndex];
                     for (int i = 0 ; i < xyseries->count() ; i++)
                     {
                         qreal x = xyseries->x(i);
                         qreal y = xyseries->y(i);
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                     }
                     XYLineChartItem* item = new XYLineChartItem(xyseries,this);
                     m_chartItems<<item;
                     foreach(ChartItem* i ,m_chartItems)
                         i->setPlotDomain(m_plotDomainList.at(m_plotDataIndex));
                     break;
                 }
                 case QChartSeries::SeriesTypeBar: {
                     qDebug() << "barSeries added";
                     BarChartSeries* barSeries = static_cast<BarChartSeries*>(series);
                     BarGroup* barGroup = new BarGroup(*barSeries,this);
                     // Add some fugly colors for 5 fist series...
                     barGroup->addColor(QColor(255,0,0,128));
                     barGroup->addColor(QColor(255,255,0,128));
                     barGroup->addColor(QColor(0,255,0,128));
                     barGroup->addColor(QColor(0,0,255,128));
                     barGroup->addColor(QColor(255,128,0,128));
                     m_chartItems<<barGroup;
                     childItems().append(barGroup);
                     break;
                     }
                 case QChartSeries::SeriesTypeStackedBar: {
                     qDebug() << "barSeries added";
                     StackedBarChartSeries* stackedBarSeries = static_cast<StackedBarChartSeries*>(series);
                     StackedBarGroup* stackedBarGroup = new StackedBarGroup(*stackedBarSeries,this);
                     // Add some fugly colors for 5 fist series...
                     stackedBarGroup->addColor(QColor(255,0,0,128));
                     stackedBarGroup->addColor(QColor(255,255,0,128));
                     stackedBarGroup->addColor(QColor(0,255,0,128));
                     stackedBarGroup->addColor(QColor(0,0,255,128));
                     stackedBarGroup->addColor(QColor(255,128,0,128));
                     m_chartItems<<stackedBarGroup;
                     childItems().append(stackedBarGroup);
                     break;
                     }
+                case QChartSeries::SeriesTypePercentBar: {
+                    qDebug() << "barSeries added";
+                    PercentBarChartSeries* percentBarSeries = static_cast<PercentBarChartSeries*>(series);
+                    PercentBarGroup* percentBarGroup = new PercentBarGroup(*percentBarSeries,this);
+                    // Add some fugly colors for 5 fist series...
+                    percentBarGroup->addColor(QColor(255,0,0,128));
+                    percentBarGroup->addColor(QColor(255,255,0,128));
+                    percentBarGroup->addColor(QColor(0,255,0,128));
+                    percentBarGroup->addColor(QColor(0,0,255,128));
+                    percentBarGroup->addColor(QColor(255,128,0,128));
+                    m_chartItems<<percentBarGroup;
+                    childItems().append(percentBarGroup);
+                    break;
+                    }
                 case QChartSeries::SeriesTypeScatter: {
                     QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                     scatterSeries->d->setParentItem(this);
                     // Set pre-defined colors in case the series has no colors defined
                     if (!scatterSeries->markerColor().isValid())
                         scatterSeries->setMarkerColor(nextColor());
                     connect(this, SIGNAL(sizeChanged(QRectF)),
                             scatterSeries, SLOT(chartSizeChanged(QRectF)));
             //        QColor nextColor = m_themeColors.takeFirst();
             //        nextColor.setAlpha(150); // TODO: default opacity?
             //        scatterSeries->setMarkerColor(nextColor);
                     break;
                     }
                 case QChartSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = qobject_cast<QPieSeries *>(series);
                     for (int i(0); i < pieSeries->sliceCount(); i++) {
                         if (!pieSeries->sliceColor(i).isValid())
                             pieSeries->setSliceColor(i, nextColor());
                     }
                     connect(this, SIGNAL(sizeChanged(QRectF)),
                             pieSeries, SLOT(chartSizeChanged(QRectF)));
                     // Set pre-defined colors in case the series has no colors defined
                     // TODO: how to define the color for all the slices of a pie?
             //        for (int (i); i < pieSeries.sliceCount(); i++)
                     break;
                     }
                 }
             }
             QChartSeries* QChart::createSeries(QChartSeries::QChartSeriesType type)
             {
                 // TODO: support also other types; not only scatter and pie
                 QChartSeries *series(0);
                 switch (type) {
                 case QChartSeries::SeriesTypeLine: {
                     series = QXYChartSeries::create();
                     break;
                 }
                 case QChartSeries::SeriesTypeBar: {
                     series = new BarChartSeries(this);
                     break;
                 }
                 case QChartSeries::SeriesTypeStackedBar: {
                     series = new StackedBarChartSeries(this);
                     break;
                 }
+                case QChartSeries::SeriesTypePercentBar: {
+                    series = new PercentBarChartSeries(this);
+                    break;
+                }
                 case QChartSeries::SeriesTypeScatter: {
                     series = new QScatterSeries(this);
                     break;
                 }
                 case QChartSeries::SeriesTypePie: {
                     series = new QPieSeries(this);
                     break;
                 }
                 default:
                     Q_ASSERT(false);
                     break;
                 }
                 addSeries(series);
                 return series;
             }
             void QChart::setSize(const QSize& size)
             {
                 m_rect = QRect(QPoint(0,0),size);
                 QRect rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                 //recaculate title
                 if(m_titleItem){
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),m_rect.top()/2 + margin()/2);
                 }
                 //recalculate background gradient
                 if(m_backgroundItem){
                     m_backgroundItem->setRect(rect);
                     if(m_bacgroundOrinetation==HorizonatlGradientOrientation)
                     m_backgroundGradient.setFinalStop(m_backgroundItem->rect().width(),0);
                     else
                     m_backgroundGradient.setFinalStop(0,m_backgroundItem->rect().height());
                     m_backgroundItem->setBrush(m_backgroundGradient);
                 }
                 //resize elements
                 foreach (ChartItem* item ,m_chartItems) {
                     item->setPos(rect.topLeft());
                     item->setSize(rect.size());
                 }
                 // TODO: TTD for setting scale
                 //emit scaleChanged(100, 100);
                 // TODO: calculate the origo
                 // TODO: not sure if emitting a signal here is the best from performance point of view
                 emit sizeChanged(QRectF(0, 0, size.width(), size.height()));
                 update();
             }
             void QChart::setBackground(const QColor& startColor, const QColor& endColor, GradientOrientation orientation)
             {
                 if(!m_backgroundItem){
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setZValue(-1);
                 }
                 m_bacgroundOrinetation = orientation;
                 m_backgroundGradient.setColorAt( 0.0, startColor);
                 m_backgroundGradient.setColorAt( 1.0, endColor);
                 m_backgroundGradient.setStart(0,0);
                 if(orientation == VerticalGradientOrientation){
                     m_backgroundGradient.setFinalStop(0,m_rect.height());
                 }else{
                     m_backgroundGradient.setFinalStop(m_rect.width(),0);
                 }
                 m_backgroundItem->setBrush(m_backgroundGradient);
                 m_backgroundItem->setPen(Qt::NoPen);
                 m_backgroundItem->update();
             }
             void QChart::setTitle(const QString& title,const QFont& font)
             {
                 if(!m_titleItem) m_titleItem = new QGraphicsTextItem(this);
                 m_titleItem->setPlainText(title);
                 m_titleItem->setFont(font);
             }
             int QChart::margin() const
             {
                 return m_marginSize;
             }
             void QChart::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void QChart::setTheme(QChart::ChartThemeId theme)
             {
             //    if (theme != m_currentTheme) {
                 m_themeColors.clear();
                 // TODO: define color themes
                 switch (theme) {
                 case QChart::ChartThemeDefault:
                     // TODO: define the default theme based on the OS
                     m_themeColors.append(QColor(QRgb(0xff000000)));
                     m_themeColors.append(QColor(QRgb(0xff707070)));
                     setBackground(QColor(QRgb(0xffffffff)), QColor(QRgb(0xffafafaf)), VerticalGradientOrientation);
                     break;
                 case QChart::ChartThemeVanilla:
                     m_themeColors.append(QColor(217, 197, 116));
                     m_themeColors.append(QColor(214, 168, 150));
                     m_themeColors.append(QColor(160, 160, 113));
                     m_themeColors.append(QColor(210, 210, 52));
                     m_themeColors.append(QColor(136, 114, 58));
                     setBackground(QColor(QRgb(0xff9d844d)), QColor(QRgb(0xffafafaf)), VerticalGradientOrientation);
                     break;
                 case QChart::ChartThemeIcy:
                     m_themeColors.append(QColor(0, 3, 165));
                     m_themeColors.append(QColor(49, 52, 123));
                     m_themeColors.append(QColor(71, 114, 187));
                     m_themeColors.append(QColor(48, 97, 87));
                     m_themeColors.append(QColor(19, 71, 90));
                     m_themeColors.append(QColor(110, 70, 228));
                     setBackground(QColor(QRgb(0xffe4ffff)), QColor(QRgb(0xffe4ffff)), VerticalGradientOrientation);
                     break;
                 case QChart::ChartThemeGrayscale:
                     m_themeColors.append(QColor(0, 0, 0));
                     m_themeColors.append(QColor(50, 50, 50));
                     m_themeColors.append(QColor(100, 100, 100));
                     m_themeColors.append(QColor(140, 140, 140));
                     m_themeColors.append(QColor(180, 180, 180));
                     setBackground(QColor(QRgb(0xffffffff)), QColor(QRgb(0xffafafaf)), VerticalGradientOrientation);
                     break;
                 case QChart::ChartThemeUnnamed1:
                     m_themeColors.append(QColor(QRgb(0xff3fa9f5)));
                     m_themeColors.append(QColor(QRgb(0xff7AC943)));
                     m_themeColors.append(QColor(QRgb(0xffFF931E)));
                     m_themeColors.append(QColor(QRgb(0xffFF1D25)));
                     m_themeColors.append(QColor(QRgb(0xffFF7BAC)));
                     setBackground(QColor(QRgb(0xfff3dc9e)), QColor(QRgb(0xffafafaf)), VerticalGradientOrientation);
                     break;
                 default:
                     Q_ASSERT(false);
                     break;
                 }
                 if(m_backgroundItem){
                 m_backgroundItem->setBrush(m_backgroundGradient);
                 m_backgroundItem->setPen(Qt::NoPen);
                 }
                 foreach(QChartSeries* series, m_chartSeries) {
                     // TODO: other series interested on themes?
                     if (series->type() == QChartSeries::SeriesTypeLine) {
                         QXYChartSeries *lineseries = reinterpret_cast<QXYChartSeries *>(series);
                         lineseries->setPen(nextColor());
                     } else if (series->type() == QChartSeries::SeriesTypeScatter) {
                         QScatterSeries *scatter = qobject_cast<QScatterSeries *>(series);
                         scatter->setMarkerColor(nextColor());
                     } else if (series->type() == QChartSeries::SeriesTypePie) {
                         QPieSeries *pieSeries = qobject_cast<QPieSeries *>(series);
                         for (int i(0); i < pieSeries->sliceCount(); i++)
                             pieSeries->setSliceColor(i, nextColor());
                     }
                 }
                 update();
             }
             QColor QChart::nextColor()
             {
                 QColor nextColor = m_themeColors.first();
                 m_themeColors.move(0, m_themeColors.size() - 1);
                 return nextColor;
             }
             void QChart::zoomInToRect(const QRect& rectangle)
             {
                 if(!rectangle.isValid()) return;
                 qreal margin = this->margin();
                 QRect rect = rectangle.normalized();
                 rect.translate(-margin, -margin);
                 PlotDomain& oldDomain = m_plotDomainList[m_plotDataIndex];
                 PlotDomain domain = oldDomain.subDomain(rect,m_rect.width() - 2 * margin,m_rect.height() - 2 * margin);
                 m_plotDomainList.resize(m_plotDataIndex + 1);
                 m_plotDomainList<<domain;
                 m_plotDataIndex++;
                 foreach (ChartItem* item ,m_chartItems)
                     item->setPlotDomain(m_plotDomainList[m_plotDataIndex]);
                 update();
             }
             void QChart::zoomIn()
             {
                 if (m_plotDataIndex < m_plotDomainList.count() - 1) {
                     m_plotDataIndex++;
                     foreach (ChartItem* item ,m_chartItems)
                         item->setPlotDomain(m_plotDomainList[m_plotDataIndex]);
                     update();
                 } else {
                     QRect rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                     rect.setWidth(rect.width()/2);
                     rect.setHeight(rect.height()/2);
                     rect.moveCenter(m_rect.center());
                     zoomInToRect(rect);
                 }
             }
             void QChart::zoomOut()
             {
                 if (m_plotDataIndex > 0) {
                     m_plotDataIndex--;
                     foreach (ChartItem* item ,m_chartItems)
                         item->setPlotDomain(m_plotDomainList[m_plotDataIndex]);
                     update();
                 }
             }
             void QChart::zoomReset()
             {
                 if (m_plotDataIndex > 0) {
                     m_plotDataIndex = 0;
                     foreach (ChartItem* item ,m_chartItems)
                         item->setPlotDomain(m_plotDomainList[m_plotDataIndex]);
                     update();
                 }
             }
             void QChart::setAxisX(const QChartAxis& axis)
             {
                 setAxis(m_axisXItem,axis);
             }
             void QChart::setAxisY(const QChartAxis& axis)
             {
                 setAxis(m_axisYItem.at(0),axis);
             }
             void QChart::setAxisY(const QList<QChartAxis>& axis)
             {
                 //TODO not implemented
             }
             void QChart::setAxis(AxisItem *item, const QChartAxis& axis)
             {
                 item->setVisible(axis.isAxisVisible());
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartseries.h +1 0

             #ifndef QCHARTSERIES_H
             #define QCHARTSERIES_H
             #include "qchartglobal.h"
             #include <QObject>
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QChartSeries : public QObject
             {
                 Q_OBJECT
             public:
                 enum QChartSeriesType {
                     SeriesTypeLine = 0,
             //        SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
+                    SeriesTypePercentBar,
                     SeriesTypePie,
                     SeriesTypeScatter
             //        SeriesTypeSpline
                 };
             protected:
                 QChartSeries(QObject *parent = 0):QObject(parent){};
             public:
                 virtual ~QChartSeries(){};
                 // Factory method
                 static QChartSeries* create(QChartSeriesType type, QObject* parent = 0 );
                 // Pure virtual
                 virtual QChartSeriesType type() const = 0;
                 virtual bool setData(QList<int> data) { return false; }
                 virtual bool setData(QList<qreal> data) { return false; }
                 virtual bool setData(QList<qreal> x, QList<qreal> y){ return false; }
                 // Prototype for data model. TODO: remove the other setData methods and use something like this for now?
                 virtual bool setData(QAbstractItemModel* model) { return false; }
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/src.pro +4 0

             !include( ../common.pri ) {
             error( Couldn't find the common.pri file! )
             }
             TARGET = QtCommercialChart
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT += core \
                 gui
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QtCommercialChartd
             SOURCES += \
                 barchart/barchartseries.cpp \
                 barchart/bargroup.cpp \
                 barchart/bar.cpp \
                 barchart/stackedbarchartseries.cpp \
                 barchart/stackedbargroup.cpp \
+                barchart/percentbarchartseries.cpp \
+                barchart/percentbargroup.cpp \
                 xylinechart/qxychartseries.cpp \
                 xylinechart/xylinechartitem.cpp \
                 plotdomain.cpp \
                 qscatterseries.cpp \
                 qpieseries.cpp \
                 qchart.cpp \
                 axisitem.cpp \
                 qchartwidget.cpp \
                 pieslice.cpp \
                 qchartview.cpp \
                 qchartseries.cpp \
                 qchartaxis.cpp
             PRIVATE_HEADERS += \
                 xylinechart/xylinechartitem_p.h \
                 plotdomain_p.h \
                 qscatterseries_p.h \
                 pieslice.h \
                 axisitem_p.h \
                 chartitem_p.h
             PUBLIC_HEADERS += \
                 qchartseries.h \
                 qscatterseries.h \
                 qpieseries.h \
                 qchart.h \
                 qchartwidget.h \
                 qchartglobal.h \
                 xylinechart/qxychartseries.h \
                 barchart/barchartseries.h \
                 barchart/bargroup.h \
                 barchart/stackedbarchartseries.h \
                 barchart/stackedbargroup.h \
+                barchart/percentbarchartseries.h \
+                barchart/percentbargroup.h \
                 qchartview.h \
                 qchartaxis.h
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             INCLUDEPATH += xylinechart \
                            barchart \
                            .
             OBJECTS_DIR = $$CHART_BUILD_DIR/lib
             MOC_DIR = $$CHART_BUILD_DIR/lib
             UI_DIR = $$CHART_BUILD_DIR/lib
             RCC_DIR = $$CHART_BUILD_DIR/lib
             DEFINES += QTCOMMERCIALCHART_LIBRARY
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target \
                 public_headers
             install_build_headers.name = bild_headers
             install_build_headers.output = $$CHART_BUILD_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_headers.input = PUBLIC_HEADERS
             install_build_headers.commands = $$QMAKE_COPY ${QMAKE_FILE_NAME} $$CHART_BUILD_HEADER_DIR
             install_build_headers.CONFIG += target_predeps no_link
             QMAKE_EXTRA_COMPILERS += install_build_headers
             chartversion.target = qchartversion_p.h
             chartversion.commands = @echo "build_time" > $$chartversion.target;
             chartversion.depends = $$HEADERS $$SOURCES
             PRE_TARGETDEPS += qchartversion_p.h
             QMAKE_CLEAN+= qchartversion_p.h
             QMAKE_EXTRA_TARGETS += chartversion
             unix:QMAKE_DISTCLEAN += -r $$CHART_BUILD_HEADER_DIR $$CHART_BUILD_LIB_DIR
             win32:QMAKE_DISTCLEAN += /Q $$CHART_BUILD_HEADER_DIR $$CHART_BUILD_LIB_DIR

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages