HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r142:d6b5513f5583

Pie chart refactoring

Jani Honkonen -

r142:d6b5513f5583

parent child

Context file:

r142:d6b5513f5583

Collapse all files

src/piechart/piepresentation.cpp created 644 +122 0

@@ -0,0 +1,122
	1
	2	#include "piepresentation.h"
	3	#include "pieslice.h"
	4	#include <QDebug>
	5
	6	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	7
	8	PiePresentation::PiePresentation(QGraphicsItem parent, QPieSeries series) :
	9	ChartItem(parent),
	10	m_pieSeries(series)
	11	{
	12	Q_ASSERT(parent);
	13	Q_ASSERT(series);
	14	m_rect = parentItem()->boundingRect();
	15	setAcceptHoverEvents(true);
	16	}
	17
	18	PiePresentation::~PiePresentation()
	19	{
	20	while (m_slices.count())
	21	delete m_slices.takeLast();
	22	}
	23
	24	void PiePresentation::seriesChanged()
	25	{
	26	const qreal fullPie = 360;
	27	qreal total = 0;
	28
	29	// calculate total
	30	foreach (QPieSlice sliceData, m_pieSeries->slices())
	31	total += sliceData.m_value;
	32
	33	// TODO: no need to create new slices in case size changed; we should re-use the existing ones
	34	while (m_slices.count())
	35	delete m_slices.takeLast();
	36
	37	// create slices
	38	qreal angle = 0;
	39	for (int i=0; i<m_pieSeries->count(); i++) {
	40	QPieSlice sliceData = m_pieSeries->slice(i);
	41	qreal span = sliceData.m_value / total * fullPie;
	42	PieSlice *slice = new PieSlice(this, i, angle, span);
	43	m_slices.append(slice);
	44	angle += span;
	45	}
	46
	47	resize();
	48	}
	49
	50	void PiePresentation::setSize(const QSizeF &size)
	51	{
	52	// TODO: allow user setting the size?
	53	// TODO: allow user defining the margins?
	54	m_rect.setSize(size);
	55	resize();
	56	}
	57
	58	void PiePresentation::setPlotDomain(const PlotDomain& plotDomain)
	59	{
	60	// TODO
	61	}
	62
	63	void PiePresentation::resize()
	64	{
	65	m_pieRect = m_rect;
	66
	67	if (m_pieRect.width() < m_pieRect.height()) {
	68	m_pieRect.setWidth(m_pieRect.width() * m_pieSeries->m_sizeFactor);
	69	m_pieRect.setHeight(m_pieRect.width());
	70	m_pieRect.moveCenter(m_rect.center());
	71	} else {
	72	m_pieRect.setHeight(m_pieRect.height() * m_pieSeries->m_sizeFactor);
	73	m_pieRect.setWidth(m_pieRect.height());
	74	m_pieRect.moveCenter(m_rect.center());
	75	}
	76
	77	switch (m_pieSeries->m_position) {
	78	case QPieSeries::PiePositionTopLeft: {
	79	m_pieRect.setHeight(m_pieRect.height() / 2);
	80	m_pieRect.setWidth(m_pieRect.height());
	81	m_pieRect.moveCenter(QPointF(m_rect.center().x() / 2, m_rect.center().y() / 2));
	82	break;
	83	}
	84	case QPieSeries::PiePositionTopRight: {
	85	m_pieRect.setHeight(m_pieRect.height() / 2);
	86	m_pieRect.setWidth(m_pieRect.height());
	87	m_pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, m_rect.center().y() / 2));
	88	break;
	89	}
	90	case QPieSeries::PiePositionBottomLeft: {
	91	m_pieRect.setHeight(m_pieRect.height() / 2);
	92	m_pieRect.setWidth(m_pieRect.height());
	93	m_pieRect.moveCenter(QPointF(m_rect.center().x() / 2, (m_rect.center().y() / 2) * 3));
	94	break;
	95	}
	96	case QPieSeries::PiePositionBottomRight: {
	97	m_pieRect.setHeight(m_pieRect.height() / 2);
	98	m_pieRect.setWidth(m_pieRect.height());
	99	m_pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, (m_rect.center().y() / 2) * 3));
	100	break;
	101	}
	102	default:
	103	break;
	104	}
	105
	106	qDebug() << "presentation rect:" << m_rect;
	107	qDebug() << "pie rect:" << m_pieRect;
	108	}
	109
	110	void PiePresentation::handleDomainChanged(const Domain& domain)
	111	{
	112	// TODO
	113	}
	114
	115	void PiePresentation::handleGeometryChanged(const QRectF& rect)
	116	{
	117	setSize(rect.size());
	118	}
	119
	120	#include "moc_piepresentation.cpp"
	121
	122	QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piepresentation.h created 644 +45 0

@@ -0,0 +1,45
	1	#ifndef PIEPRESENTATION_H
	2	#define PIEPRESENTATION_H
	3
	4	#include "chartitem_p.h"
	5	#include "qpieseries.h"
	6
	7	class QGraphicsItem;
	8	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	9	class PieSlice;
	10
	11	class PiePresentation : public QObject, public ChartItem
	12	{
	13	Q_OBJECT
	14
	15	public:
	16	// TODO: use a generic data class instead of x and y
	17	PiePresentation(QGraphicsItem parent, QPieSeries series);
	18	~PiePresentation();
	19
	20	public: // from ChartItem
	21	void setSize(const QSizeF &size);
	22	void setPlotDomain(const PlotDomain& data);
	23	QRectF boundingRect() const { return m_rect; }
	24	void paint(QPainter , const QStyleOptionGraphicsItem , QWidget *) {}
	25
	26	public:
	27	void seriesChanged();
	28	void resize();
	29	QRectF pieRect() const { return m_pieRect; }
	30
	31	public Q_SLOTS:
	32	void handleDomainChanged(const Domain& domain);
	33	void handleGeometryChanged(const QRectF& rect);
	34
	35	private:
	36	friend class PieSlice;
	37	QList<PieSlice*> m_slices;
	38	QPieSeries *m_pieSeries;
	39	QRectF m_rect;
	40	QRectF m_pieRect;
	41	};
	42
	43	QTCOMMERCIALCHART_END_NAMESPACE
	44
	45	#endif // PIEPRESENTATION_H

src/piechart/qpieseries.cpp created 644 +93 0

@@ -0,0 +1,93
	1	#include "qpieseries.h"
	2	#include "piepresentation.h"
	3	#include "pieslice.h"
	4	#include <QDebug>
	5
	6	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	7
	8	QPieSeries::QPieSeries(QObject *parent) :
	9	QChartSeries(parent),
	10	m_piePresentation(0),
	11	m_sizeFactor(1.0),
	12	m_position(PiePositionMaximized)
	13	{
	14	}
	15
	16	QPieSeries::~QPieSeries()
	17	{
	18
	19	}
	20
	21	void QPieSeries::set(QList<QPieSlice> slices)
	22	{
	23	m_slices = slices;
	24	if (m_piePresentation) {
	25	m_piePresentation->seriesChanged();
	26	m_piePresentation->update();
	27	}
	28	}
	29
	30	void QPieSeries::add(QList<QPieSlice> slices)
	31	{
	32	m_slices += slices;
	33	if (m_piePresentation) {
	34	m_piePresentation->seriesChanged();
	35	// TODO: m_piePresentation->seriesAppended()??
	36	m_piePresentation->update();
	37	}
	38	}
	39
	40	void QPieSeries::add(QPieSlice slice)
	41	{
	42	add(QList<QPieSlice>() << slice);
	43	}
	44
	45	QPieSlice QPieSeries::slice(int index) const
	46	{
	47	if ((index >= 0) && (index < m_slices.count()))
	48	return m_slices.at(index);
	49	return QPieSlice();
	50	}
	51
	52	bool QPieSeries::update(int index, QPieSlice slice)
	53	{
	54	if ((index >= 0) && (index < m_slices.count())) {
	55	m_slices[index] = slice;
	56	if (m_piePresentation) {
	57	m_piePresentation->seriesChanged();
	58	// TODO: for a nice animation we need something like
	59	// m_piePresentation->sliceChanged(index, oldslice, newslice)
	60	m_piePresentation->update();
	61	}
	62	return true;
	63	}
	64	return false;
	65	}
	66
	67	void QPieSeries::setSizeFactor(qreal factor)
	68	{
	69	if (factor > 0.0)
	70	m_sizeFactor = factor;
	71
	72	if (m_piePresentation) {
	73	m_piePresentation->resize();
	74	m_piePresentation->update();
	75	// TODO: do we have to update the parent item also?
	76	// - potential issue: what if this function is called from the parent context?
	77	}
	78	}
	79
	80	void QPieSeries::setPosition(PiePosition position)
	81	{
	82	m_position = position;
	83	if (m_piePresentation) {
	84	m_piePresentation->resize();
	85	m_piePresentation->update();
	86	// TODO: do we have to update the parent item also?
	87	// - potential issue: what if this function is called from the parent context?
	88	}
	89	}
	90
	91	#include "moc_qpieseries.cpp"
	92
	93	QTCOMMERCIALCHART_END_NAMESPACE

example/piechart/main.cpp +5 -6

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <cmath>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qpieseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 // Create widget and scatter series
                 QChartView *chartWidget = new QChartView();
                 QPieSeries *series = qobject_cast<QPieSeries *>(chartWidget->createSeries(QChartSeries::SeriesTypePie));
                 Q_ASSERT(series);
                 // Add test data to the series
-                QList<qreal> x;
+                series->add(QPieSlice(1, "test1", Qt::red));
-                for (qreal i(0.0); i < 20; i += 0.5) {
+                series->add(QPieSlice(2, "test2", Qt::green));
-                    // Linear data with random component
+                series->add(QPieSlice(3, "test3", Qt::blue));
-                    x.append(i + ((qreal)(rand() % 100)) / 100 );
+                series->add(QPieSlice(4, "test4", Qt::darkRed));
+                series->add(QPieSlice(5, "test5", Qt::darkGreen));
-                series->setData(x);
                 // Use the chart widget as the central widget
                 QMainWindow w;
                 w.resize(640, 480);
                 w.setCentralWidget(chartWidget);
                 w.show();
                 return a.exec();
             }

src/chartdataset.cpp +8 0

             #include "chartdataset_p.h"
             //series
             #include "qxychartseries.h"
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
+            #include "piechart/qpieseries.h"
+            #include "piechart/piepresentation.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QObject *parent):QObject(parent)
             {
                 Domain domain;
                 m_domains<<domain;
             }
             ChartDataSet::~ChartDataSet()
             {
                 // TODO Auto-generated destructor stub
             }
             const Domain& ChartDataSet::domain() const
             {
                 return m_domains[m_domainIndex];
             }
             void ChartDataSet::addSeries(QChartSeries* series)
             {
                 // TODO: we should check the series not already added
                 m_chartSeries << series;
                 m_domainIndex = 0;
                 m_domains.resize(1);
                 Domain& domain = m_domains[m_domainIndex];
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QXYChartSeries* xyseries = static_cast<QXYChartSeries*>(series);
                         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);
                         }
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         BarChartSeries* barSeries = static_cast<BarChartSeries*>(series);
                         qreal x = barSeries->countColumns();
                         qreal y = barSeries->max();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                     }
                     break;
                     case QChartSeries::SeriesTypeStackedBar: {
                         StackedBarChartSeries* stackedBarSeries = static_cast<StackedBarChartSeries*>(series);
                         qreal x = stackedBarSeries->countColumns();
                         qreal y = stackedBarSeries->maxColumnSum();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                     }
                         break;
                     case QChartSeries::SeriesTypePercentBar: {
                         PercentBarChartSeries* percentBarSeries = static_cast<PercentBarChartSeries*>(series);
                         qreal x = percentBarSeries->countColumns();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = 0;
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = 100;
                     }
                         break;
+                    case QChartSeries::SeriesTypePie: {
+                        QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
+                        // TODO: domain stuff
+                        break;
+                    }
                     default: {
                         qDebug()<<__FUNCTION__<<"type" << series->type()<<"not supported";
                         return;
                         break;
                     }
                 }
                 emit seriesAdded(series);
                 emit domainChanged(domain);
             }
             bool ChartDataSet::nextDomain()
             {
                 if (m_domainIndex < m_domains.count() - 1) {
                     m_domainIndex++;
                     emit domainChanged(m_domains[m_domainIndex]);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             bool ChartDataSet::previousDomain()
             {
                 if (m_domainIndex > 0) {
                     m_domainIndex--;
                     emit domainChanged(m_domains[m_domainIndex]);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             void ChartDataSet::clearDomains()
             {
                 if (m_domainIndex > 0) {
                     m_domainIndex = 0;
                     emit domainChanged(m_domains[m_domainIndex]);
                 }
             }
             void ChartDataSet::addDomain(const Domain& domain)
             {
                 m_domains.resize(m_domainIndex + 1);
                 m_domains << domain;
                 m_domainIndex++;
                 emit domainChanged(domain);
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +12 -11

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             //series
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qxychartseries.h"
+            #include "qpieseries.h"
             //items
             #include "axisitem_p.h"
             #include "bargroup.h"
             #include "stackedbargroup.h"
             #include "xylinechartitem_p.h"
             #include "percentbargroup.h"
             #include "linechartanimationitem_p.h"
+            #include "piepresentation.h"
             #include <QAbstractAnimation>
             #include <QPropertyAnimation>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_dataset(dataset),
             m_domainIndex(0),
             m_marginSize(0),
             m_rect(QRectF(QPoint(0,0),m_chart->size()))
             {
                 createConnections();
                 createDeafultAxis();
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::createDeafultAxis()
             {
                 //default axis
                 QChartAxis* axisX = new QChartAxis(this);
                 QChartAxis* axisY = new QChartAxis(this);
                 m_axis << new AxisItem(axisX,AxisItem::X_AXIS,m_chart);
                 m_axis << new AxisItem(axisY,AxisItem::Y_AXIS,m_chart);
                 foreach(AxisItem* item, m_axis) {
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                 }
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QChartSeries*)),this,SLOT(handleSeriesAdded(QChartSeries*)));
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 m_rect = QRectF(QPoint(0,0),m_chart->size());
                 m_rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 emit geometryChanged(m_rect);
             }
             int ChartPresenter::margin() const
             {
                 return m_marginSize;
             }
             void ChartPresenter::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void ChartPresenter::handleSeriesAdded(QChartSeries* series)
             {
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QXYChartSeries* lineSeries = static_cast<QXYChartSeries*>(series);
                         XYLineChartItem* item = new LineChartAnimationItem(this,lineSeries,m_chart);
                         item->setPen(lineSeries->pen());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(lineSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         BarChartSeries* barSeries = static_cast<BarChartSeries*>(series);
                         BarGroup* item = new BarGroup(*barSeries,m_chart);
                         // Add some fugly colors for 5 fist series...
                         item->addColor(QColor(255,0,0,128));
                         item->addColor(QColor(255,255,0,128));
                         item->addColor(QColor(0,255,0,128));
                         item->addColor(QColor(0,0,255,128));
                         item->addColor(QColor(255,128,0,128));
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(barSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         // m_axisXItem->setVisible(false);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         StackedBarChartSeries* stackedBarSeries = static_cast<StackedBarChartSeries*>(series);
                         StackedBarGroup* item = new StackedBarGroup(*stackedBarSeries,m_chart);
                         // Add some fugly colors for 5 fist series...
                         item->addColor(QColor(255,0,0,128));
                         item->addColor(QColor(255,255,0,128));
                         item->addColor(QColor(0,255,0,128));
                         item->addColor(QColor(0,0,255,128));
                         item->addColor(QColor(255,128,0,128));
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(stackedBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         PercentBarChartSeries* percentBarSeries = static_cast<PercentBarChartSeries*>(series);
                         PercentBarGroup* item = new PercentBarGroup(*percentBarSeries,m_chart);
                         // Add some fugly colors for 5 fist series...
                         item->addColor(QColor(255,0,0,128));
                         item->addColor(QColor(255,255,0,128));
                         item->addColor(QColor(0,255,0,128));
                         item->addColor(QColor(0,0,255,128));
                         item->addColor(QColor(255,128,0,128));
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(percentBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     /*
                      case QChartSeries::SeriesTypeScatter: {
                      QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                      scatterSeries->d->m_theme = m_chartTheme->themeForSeries();
                      scatterSeries->d->setParentItem(this);
                      scatterSeries->d->m_boundingRect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                      m_chartItems << scatterSeries->d;
                      m_chartTheme->addObserver(scatterSeries->d);
                      foreach (qreal x, scatterSeries->d->m_x) {
                      domain.m_minX = qMin(domain.m_minX, x);
                      domain.m_maxX = qMax(domain.m_maxX, x);
                      }
                      foreach (qreal y, scatterSeries->d->m_y) {
                      domain.m_minY = qMin(domain.m_minY, y);
                      domain.m_maxY = qMax(domain.m_maxY, y);
                      }
                      break;
                      }
-                     case QChartSeries::SeriesTypePie: {
-                     QPieSeries *pieSeries = qobject_cast<QPieSeries *>(series);
-                     pieSeries->d->setParentItem(this);
-                     m_chartItems << pieSeries->d;
-                     pieSeries->d->m_chartTheme = m_chartTheme;
-                     m_chartTheme->addObserver(pieSeries->d);
-                     break;
-                     default:
-                     break;
                      */
+                    case QChartSeries::SeriesTypePie: {
+                        QPieSeries *pieSeries = qobject_cast<QPieSeries *>(series);
+                        PiePresentation* pieChart = new PiePresentation(m_chart, pieSeries);
+                        pieSeries->m_piePresentation = pieChart; // TODO: remove this pointer passing use signals&slots
+                        QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pieChart, SLOT(handleGeometryChanged(const QRectF&)));
+                        QObject::connect(m_dataset, SIGNAL(domainChanged(const Domain&)), pieChart, SLOT(handleDomainChanged(const Domain&)));
+                        m_chartItems.insert(series, pieChart);
+                        break;
+                    }
                     default: {
                         qDebug()<< "Series type" << series->type() << "not implemented.";
                         break;
                     }
                 }
             }
             void ChartPresenter::handleSeriesChanged(QChartSeries* series)
             {
                 //TODO:
             }
             void ChartPresenter::zoomInToRect(const QRectF& rect)
             {
                 if(!rect.isValid()) return;
                 QRectF r = rect.normalized();
                 r.translate(-m_marginSize, -m_marginSize);
                 Domain domain (m_dataset->domain().subDomain(rect,m_rect.width(),m_rect.height()));
                 m_dataset->addDomain(domain);
             }
             void ChartPresenter::zoomIn()
             {
                 if (!m_dataset->nextDomain()) {
                     QRectF rect = m_rect;
                     rect.setWidth(rect.width()/2);
                     rect.setHeight(rect.height()/2);
                     rect.moveCenter(m_rect.center());
                     Domain domain (m_dataset->domain().subDomain(rect,m_rect.width(),m_rect.height()));
                     m_dataset->addDomain(domain);
                 }
             }
             void ChartPresenter::zoomOut()
             {
                 m_dataset->previousDomain();
             }
             void ChartPresenter::zoomReset()
             {
                 m_dataset->clearDomains();
             }
             /*
              void ChartPresenter::setAxisX(const QChartAxis& axis)
              {
              setAxis(m_axisXItem,axis);
              }
              void ChartPresenter::setAxisY(const QChartAxis& axis)
              {
              setAxis(m_axisYItem.at(0),axis);
              }
              void ChartPresenter::setAxisY(const QList<QChartAxis>& axis)
              {
              //TODO not implemented
              }
              void ChartPresenter::setAxis(AxisItem *item, const QChartAxis& axis)
              {
              item->setVisible(axis.isAxisVisible());
              }
              */
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslice.cpp ~~src/pieslice.cpp~~ renamed +26 -10

             #include "pieslice.h"
+            #include "piepresentation.h"
             #include <QPainter>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            PieSlice::PieSlice(const QColor& color, qreal startAngle, qreal span, QRectF rect)
+            PieSlice::PieSlice(PiePresentation *piePresentation, int seriesIndex, qreal startAngle, qreal span)
-                : m_color(color),
+                :QGraphicsItem(piePresentation),
+                m_seriesIndex(seriesIndex),
                 m_startAngle(startAngle),
-                m_span(span),
+                m_span(span)
-                m_rect(rect)
             {
+                Q_ASSERT(piePresentation);
                 setAcceptHoverEvents(true);
+                setAcceptedMouseButtons(Qt::LeftButton);
             }
             PieSlice::~PieSlice()
             {
             }
             QRectF PieSlice::boundingRect() const
             {
-                return m_rect;
+                return shape().boundingRect();
             }
             QPainterPath PieSlice::shape() const
             {
+                QRectF rect = (static_cast<PiePresentation*>(parentItem()))->pieRect();
                 qreal angle = (-m_startAngle) + (90);
                 qreal span = -m_span;
                 QPainterPath path;
-                path.moveTo(boundingRect().center());
+                path.moveTo(rect.center());
-                path.arcTo(boundingRect(), angle, span);
+                path.arcTo(rect, angle, span);
                 // TODO: draw the shape so that it might have a hole in the center
                 // - Sin & Cos will be needed to find inner/outer arc endpoints
                 // dx, dy are offsets from the center
                 //qreal l = boundingRect().height();
                 //qreal dx = qSin(angle*(M_PI/180)) * l;
                 //qreal dy = qCos(angle*(M_PI/180)) * l;
                 // TODO: exploded slice?
                 return path;
             }
-            void PieSlice::paint(QPainter *painter, const QStyleOptionGraphicsItem */*option*/, QWidget */*widget*/)
+            void PieSlice::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->setRenderHint(QPainter::Antialiasing);
                 // TODO: how to map theme settings to a pie slice? Now we
                 //painter->setPen(m_theme.linePen);
                 // TODO:
-                painter->setBrush(m_theme.linePen.color());
+                QPieSlice data = (static_cast<PiePresentation*>(parentItem()))->m_pieSeries->slice(m_seriesIndex);
+                painter->setBrush(data.m_color);
+                //painter->setBrush(m_theme.linePen.color());
                 // From Qt docs:
                 // The startAngle and spanAngle must be specified in 1/16th of a degree, i.e. a full circle equals 5760 (16 * 360).
                 // Positive values for the angles mean counter-clockwise while negative values mean the clockwise direction.
                 // Zero degrees is at the 3 o'clock position.
                 //
                 // For sake of simplicity convert this so that zero degrees is at 12 o'clock and full circle is 360.
                 //qreal angle = (-m_startAngle*16) + (90*16);
                 //qreal span = -m_span*16;
                 //painter->drawPie(boundingRect(), angle, span);
                 painter->drawPath(shape());
+                // Draw the label
+                // TODO: do this better
+                painter->drawText(boundingRect().center(), data.m_label);
             }
             void PieSlice::hoverEnterEvent(QGraphicsSceneHoverEvent * event)
             {
                 QGraphicsItem::hoverEnterEvent(event);
-                qDebug() << "hover" << m_color << m_startAngle << m_span;
+                qDebug() << "hover" << m_seriesIndex << m_startAngle << m_span;
             }
+            void PieSlice::mousePressEvent(QGraphicsSceneMouseEvent *event)
+            {
+                QGraphicsItem::mousePressEvent(event);
+            }
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslice.h ~~src/pieslice.h~~ renamed +7 -6

             #ifndef PIESLICE_H
             #define PIESLICE_H
             #include "qchartglobal.h"
             #include "charttheme_p.h"
             #include <QGraphicsItem>
             #include <QRectF>
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            class PiePresentation;
             class PieSlice : public QGraphicsItem
             {
             public:
-                PieSlice(const QColor& color, qreal startAngle, qreal span, QRectF rect);
+                PieSlice(PiePresentation *piePresentation, int seriesIndex, qreal startAngle, qreal span);
                 ~PieSlice();
             public: // from QGraphicsItem
                 QRectF boundingRect() const;
                 QPainterPath shape() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
-                void hoverEnterEvent(QGraphicsSceneHoverEvent * event);
+                void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
+                void mousePressEvent(QGraphicsSceneMouseEvent *event);
-            public:
+            private:
-                QColor m_color;
+                int m_seriesIndex;
                 qreal m_startAngle;
                 qreal m_span;
-                QRectF m_rect;
+                //SeriesTheme m_theme;
-                SeriesTheme m_theme;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICE_H

src/piechart/qpieseries.h ~~src/qpieseries.h~~ renamed +44 -11

             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include "qchartseries.h"
             #include <QObject>
             #include <QRectF>
             #include <QColor>
             class QGraphicsObject;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QPieSeriesPrivate;
+            class PiePresentation;
             class PieSlice;
+            class QPieSlice
+            {
+            public:
+                QPieSlice()
+                    :m_value(0), m_label("<empty>"), m_color(Qt::white), m_isExploded(false) {}
+                QPieSlice(qreal value, QString label, QColor color, bool exploded = false)
+                    :m_value(value), m_label(label), m_color(color), m_isExploded(exploded) {}
+            public:
+                qreal m_value;
+                QString m_label;
+                QColor m_color;
+                bool m_isExploded;
+            };
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
                 enum PiePosition {
                     PiePositionMaximized = 0,
                     PiePositionTopLeft,
                     PiePositionTopRight,
                     PiePositionBottomLeft,
                     PiePositionBottomRight
                 };
             public:
-                // TODO: use a generic data class instead of x and y
+                QPieSeries(QObject *parent = 0);
-                QPieSeries(QGraphicsObject *parent = 0);
                 ~QPieSeries();
             public: // from QChartSeries
                 QChartSeriesType type() const { return QChartSeries::SeriesTypePie; }
-                bool setData(QList<qreal> data);
             public:
-                void setSliceColor(int index, QColor color);
+                void set(QList<QPieSlice> slices);
-                QColor sliceColor(int index);
+                void add(QList<QPieSlice> slices);
-                int sliceCount();
+                void add(QPieSlice slice);
+                int count() const { return m_slices.count(); }
+                QList<QPieSlice> slices() const { return m_slices; }
+                QPieSlice slice(int index) const;
+                bool update(int index, QPieSlice slice);
+                // TODO: convenience functions
+                //void updateValue(int sliceIndex, qreal value);
+                //void updateLabel(int sliceIndex, QString label);
+                //void updateColor(int sliceIndex, QColor color);
+                //void updateExploded(int slizeIndex, bool exploded);
                 void setSizeFactor(qreal sizeFactor);
-                qreal sizeFactor();
+                qreal sizeFactor() const { return m_sizeFactor; }
                 void setPosition(PiePosition position);
+                PiePosition position() const { return m_position; }
             private:
-                Q_DECLARE_PRIVATE(QPieSeries)
                 Q_DISABLE_COPY(QPieSeries)
-                friend class QChart;
+                // TODO: use PIML
-                QPieSeriesPrivate *const d;
+                friend class ChartPresenter;
+                friend class ChartDataSet;
+                friend class PiePresentation;
+                PiePresentation *m_piePresentation;
+                QList<QPieSlice> m_slices;
+                qreal m_sizeFactor;
+                PiePosition m_position;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/qchart.cpp +1 -2

             #include "qchart.h"
             #include "qchartseries.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "qpieseries.h"
-            #include "qpieseries_p.h"
             #include "qchartaxis.h"
             #include "charttheme_p.h"
             #include "chartitem_p.h"
             #include "plotdomain_p.h"
             #include "axisitem_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             //series
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qxychartseries.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
                 m_backgroundItem(0),
                 m_titleItem(0),
                 m_axisXItem(0),
                 m_chartTheme(new ChartTheme(this)),
                 //m_dataset(0),
                 m_dataset(new ChartDataSet(this)),
                 //m_presenter(0)
                 m_presenter(new ChartPresenter(this,m_dataset))
             {
                 // TODO: the default theme?
                 setTheme(QChart::ChartThemeDefault);
                 //m_chartItems << m_axisXItem;
                 //m_chartItems << m_axisYItem.at(0);
             }
             QChart::~QChart(){}
             void QChart::addSeries(QChartSeries* series)
             {
                m_dataset->addSeries(series);
             }
             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::setChartBackgroundBrush(const QBrush& brush)
             {
                 if(!m_backgroundItem){
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setZValue(-1);
                 }
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
             void QChart::setChartBackgroundPen(const QPen& pen)
             {
                 if(!m_backgroundItem){
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setZValue(-1);
                 }
                 m_backgroundItem->setPen(pen);
                 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
             {
-                m_presenter->margin();
+                return m_presenter->margin();
             }
             void QChart::setMargin(int margin)
             {
                m_presenter->setMargin(margin);
             }
             void QChart::setTheme(QChart::ChartThemeId theme)
             {
                 m_chartTheme->setTheme(theme);
                 QLinearGradient backgroundGradient;
                 backgroundGradient.setColorAt(0.0, m_chartTheme->d->m_gradientStartColor);
                 backgroundGradient.setColorAt(1.0, m_chartTheme->d->m_gradientEndColor);
                 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                 setChartBackgroundBrush(backgroundGradient);
                 // TODO: Move the controlling of the series presentations into private implementation of the
                 // series instead of QChart controlling themes for each
                 // In other words, the following should be used when creating xy series:
                 // m_chartTheme->addObserver(xyseries)
                 foreach (QChartSeries *series, m_chartSeries) {
                     if (series->type() == QChartSeries::SeriesTypeLine) {
                         QXYChartSeries *xyseries = static_cast<QXYChartSeries *>(series);
                         SeriesTheme seriesTheme = m_chartTheme->themeForSeries();
                         xyseries->setPen(seriesTheme.linePen);
                     }
                 }
                 update();
             }
             QChart::ChartThemeId QChart::theme()
             {
                 return (QChart::ChartThemeId) m_chartTheme->d->m_currentTheme;
             }
             void QChart::zoomInToRect(const QRectF& rectangle)
             {
                 m_presenter->zoomInToRect(rectangle);
             }
             void QChart::zoomIn()
             {
                 m_presenter->zoomIn();
             }
             void QChart::zoomOut()
             {
                 m_presenter->zoomOut();
             }
             void QChart::zoomReset()
             {
                 m_presenter->zoomReset();
             }
             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());
             }
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 m_rect = QRectF(QPoint(0,0),event->newSize());
                 QRectF rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                 // recalculate title position
                 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);
                 }
                 QGraphicsWidget::resizeEvent(event);
                 update();
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/src.pro +9 -5

             !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 \
                 barchart/barlabel.cpp \
                 xylinechart/qxychartseries.cpp \
                 xylinechart/xylinechartitem.cpp \
                 xylinechart/linechartanimationitem.cpp \
+                piechart/qpieseries.cpp \
+                piechart/pieslice.cpp \
+                piechart/piepresentation.cpp \
                 plotdomain.cpp \
                 qscatterseries.cpp \
-                qpieseries.cpp \
                 qchart.cpp \
                 axisitem.cpp \
-                pieslice.cpp \
                 qchartview.cpp \
                 qchartseries.cpp \
                 qchartaxis.cpp \
                 charttheme.cpp \
                 barchart/separator.cpp \
                 barchart/bargroupbase.cpp \
                 barchart/barchartseriesbase.cpp \
                 chartdataset.cpp \
                 chartpresenter.cpp \
                 domain.cpp
             PRIVATE_HEADERS += \
                 xylinechart/xylinechartitem_p.h \
                 xylinechart/linechartanimationitem_p.h \
                 barchart/barlabel_p.h \
                 barchart/bar_p.h \
                 barchart/separator_p.h \
+                piechart/piepresentation.h \
+                piechart/pieslice.h \
                 plotdomain_p.h \
                 qscatterseries_p.h \
-                qpieseries_p.h \
-                pieslice.h \
                 axisitem_p.h \
                 chartitem_p.h \
                 charttheme_p.h \
                 chartdataset_p.h \
                 chartpresenter_p.h \
                 domain_p.h
             PUBLIC_HEADERS += \
                 qchartseries.h \
                 qscatterseries.h \
-                qpieseries.h \
                 qchart.h \
                 qchartglobal.h \
                 xylinechart/qxychartseries.h \
                 barchart/barchartseries.h \
                 barchart/bargroup.h \
                 barchart/stackedbarchartseries.h \
                 barchart/stackedbargroup.h \
                 barchart/percentbarchartseries.h \
                 barchart/percentbargroup.h \
                 barchart/barchartseriesbase.h \
                 barchart/bargroupbase.h \
+                piechart/qpieseries.h \
                 qchartview.h \
                 qchartaxis.h
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             INCLUDEPATH += xylinechart \
                            barchart \
+                           piechart \
                            .
             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

src/qpieseries.cpp removed 0 -186

NO CONTENT: file was removed

src/qpieseries_p.h removed 0 -45

NO CONTENT: file was removed

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