HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r157:036a0ec8efe0

Use signals from pieseries, visible hover and exploding slices

Jani Honkonen -

r157:036a0ec8efe0

parent child

Context file:

r157:036a0ec8efe0

Collapse all files

example/piechart/main.cpp +2 -2

             #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
-                series->add(QPieSlice(1, "test1", Qt::red));
+                series->add(QPieSlice(1, "test1", Qt::red, true));
                 series->add(QPieSlice(2, "test2", Qt::green));
                 series->add(QPieSlice(3, "test3", Qt::blue));
-                series->add(QPieSlice(4, "test4", Qt::darkRed));
+                series->add(QPieSlice(4, "test4", Qt::darkRed, true));
                 series->add(QPieSlice(5, "test5", Qt::darkGreen));
                 // Use the chart widget as the central widget
                 QMainWindow w;
                 w.resize(640, 480);
                 w.setCentralWidget(chartWidget);
                 w.show();
                 return a.exec();
             }

src/chartpresenter.cpp +1 -1

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             //series
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qlinechartseries.h"
             #include "qpieseries.h"
             //items
             #include "axisitem_p.h"
             #include "bargroup.h"
             #include "stackedbargroup.h"
             #include "linechartitem_p.h"
             #include "percentbargroup.h"
             #include "linechartanimationitem_p.h"
             #include "piepresenter.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_dataset(dataset),
             m_chartTheme(0),
             m_domainIndex(0),
             m_marginSize(0),
             m_axisX(new QChartAxis(this)),
             m_axisY(new QChartAxis(this)),
             m_rect(QRectF(QPoint(0,0),m_chart->size()))
             {
                 setChartTheme(QChart::ChartThemeDefault);
                 m_axisItems[m_axisX] = new AxisItem(m_axisX,AxisItem::X_AXIS,m_chart);
                 m_axisItems[m_axisY] = new AxisItem(m_axisY,AxisItem::Y_AXIS,m_chart);
                 createConnections();
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QChartSeries*)),this,SLOT(handleSeriesAdded(QChartSeries*)));
                 QMapIterator<QChartAxis*,AxisItem*> i(m_axisItems);
                 while (i.hasNext()) {
                     i.next();
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),i.value(),SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),i.value(),SLOT(handleDomainChanged(const Domain&)));
                 }
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 m_rect = QRectF(QPoint(0,0),m_chart->size());
                 m_rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 Q_ASSERT(m_rect.isValid());
                 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: {
                         QLineChartSeries* lineSeries = static_cast<QLineChartSeries*>(series);
                         LineChartItem* item = new LineChartAnimationItem(this,lineSeries,m_chart);
                         m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
                         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);
                         m_chartTheme->decorate(item,barSeries,m_chartItems.count());
                         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);
                         m_chartTheme->decorate(item,stackedBarSeries,m_chartItems.count());
                         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);
                         m_chartTheme->decorate(item,percentBarSeries ,m_chartItems.count());
                         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);
                         PiePresenter* pie = new PiePresenter(m_chart, pieSeries);
-                        pieSeries->m_piePresenter = pie; // TODO: remove this pointer passing use signals&slots
+                        QObject::connect(pieSeries, SIGNAL(changed(const PieChangeSet&)), pie, SLOT(handleSeriesChanged(const PieChangeSet&)));
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset, SIGNAL(domainChanged(const Domain&)), pie, SLOT(handleDomainChanged(const Domain&)));
                         m_chartItems.insert(series, pie);
                         break;
                     }
                     default: {
                         qDebug()<< "Series type" << series->type() << "not implemented.";
                         break;
                     }
                 }
                 if(m_rect.isValid()) emit geometryChanged(m_rect);
             }
             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(r,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::setChartTheme(QChart::ChartTheme theme)
             {
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
                 QMapIterator<QChartSeries*,ChartItem*> i(m_chartItems);
                 int index=0;
                 while (i.hasNext()) {
                     i.next();
                     index++;
                     m_chartTheme->decorate(i.value(),i.key(),index);
                   }
                 }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             QChartAxis* ChartPresenter::axisX()
             {
                return m_axisX;
             }
             QChartAxis* ChartPresenter::axisY()
             {
                return m_axisY;
             }
             QChartAxis* ChartPresenter::addAxisX()
             {
               //only one axis
               if(m_axisX==0){
                   m_axisX = new QChartAxis(this);
                   m_axisItems[m_axisX] = new AxisItem(m_axisX,AxisItem::X_AXIS,m_chart);
               }
               return m_axisX;
             }
             QChartAxis* ChartPresenter::addAxisY()
             {
                 if(m_axisY==0){
                     m_axisY = new QChartAxis(this);
                     m_axisItems[m_axisY] = new AxisItem(m_axisY,AxisItem::Y_AXIS,m_chart);
                     return m_axisY;
                 }
                 QChartAxis* axis = new QChartAxis(this);
                 m_axisItems[axis] = new AxisItem(axis,AxisItem::Y_AXIS,m_chart);
                 return axis;
             }
             void ChartPresenter::removeAxis(QChartAxis* axis)
             {
                 AxisItem* item = m_axisItems.take(axis);
                 if(item){
                     delete item;
                     delete axis;
                 }
                 //reset pointers to default ones
                 if(axis == m_axisX) m_axisX=0;
                 else if(axis == m_axisY) m_axisY=0;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piepresenter.cpp +12 -11

             #include "piepresenter.h"
             #include "pieslice.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PiePresenter::PiePresenter(QGraphicsItem *parent, QPieSeries *series) :
                 ChartItem(parent),
                 m_pieSeries(series)
             {
                 Q_ASSERT(parent);
                 Q_ASSERT(series);
                 m_rect = parentItem()->boundingRect();
                 setAcceptHoverEvents(true);
             }
             PiePresenter::~PiePresenter()
             {
                 while (m_slices.count())
                     delete m_slices.takeLast();
             }
-            void PiePresenter::seriesChanged()
+            void PiePresenter::handleSeriesChanged(const PieChangeSet& changeSet)
             {
                 const qreal fullPie = 360;
                 qreal total = 0;
                 // calculate total
                 foreach (QPieSlice sliceData, m_pieSeries->slices())
                     total += sliceData.m_value;
                 // TODO: no need to create new slices in case size changed; we should re-use the existing ones
                 while (m_slices.count())
                     delete m_slices.takeLast();
                 // create slices
                 qreal angle = 0;
                 for (int i=0; i<m_pieSeries->count(); i++) {
                     QPieSlice sliceData = m_pieSeries->slice(i);
                     qreal span = sliceData.m_value / total * fullPie;
                     PieSlice *slice = new PieSlice(this, i, angle, span);
                     m_slices.append(slice);
                     angle += span;
                 }
-                resize();
             }
-            void PiePresenter::resize()
+            void PiePresenter::updateGeometry()
             {
+                prepareGeometryChange();
                 m_pieRect = m_rect;
                 if (m_pieRect.width() < m_pieRect.height()) {
-                    m_pieRect.setWidth(m_pieRect.width() * m_pieSeries->m_sizeFactor);
+                    m_pieRect.setWidth(m_pieRect.width() * m_pieSeries->sizeFactor());
                     m_pieRect.setHeight(m_pieRect.width());
                     m_pieRect.moveCenter(m_rect.center());
                 } else {
-                    m_pieRect.setHeight(m_pieRect.height() * m_pieSeries->m_sizeFactor);
+                    m_pieRect.setHeight(m_pieRect.height() * m_pieSeries->sizeFactor());
                     m_pieRect.setWidth(m_pieRect.height());
                     m_pieRect.moveCenter(m_rect.center());
                 }
-                switch (m_pieSeries->m_position) {
+                switch (m_pieSeries->position()) {
                     case QPieSeries::PiePositionTopLeft: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF(m_rect.center().x() / 2, m_rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionTopRight: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, m_rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionBottomLeft: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF(m_rect.center().x() / 2, (m_rect.center().y() / 2) * 3));
                         break;
                     }
                     case QPieSeries::PiePositionBottomRight: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, (m_rect.center().y() / 2) * 3));
                         break;
                     }
                     default:
                         break;
                 }
                 qDebug() << "presentation rect:" << m_rect;
                 qDebug() << "pie rect:" << m_pieRect;
+                foreach (PieSlice *slice, m_slices)
+                    slice->updateGeometry();
             }
             void PiePresenter::handleDomainChanged(const Domain& domain)
             {
                 // TODO
             }
             void PiePresenter::handleGeometryChanged(const QRectF& rect)
             {
-                // TODO: allow user setting the size?
+                m_rect = rect;
-                // TODO: allow user defining the margins?
+                updateGeometry();
-                m_rect.setSize(rect.size());
-                resize();
             }
             #include "moc_piepresenter.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piepresenter.h +3 -3

             #ifndef PIEPRESENTER_H
             #define PIEPRESENTER_H
             #include "chartitem_p.h"
             #include "qpieseries.h"
             class QGraphicsItem;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieSlice;
             class PiePresenter : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 // TODO: use a generic data class instead of x and y
                 PiePresenter(QGraphicsItem *parent, QPieSeries *series);
                 ~PiePresenter();
-            public: // from ChartItem
+            public: // from QGraphicsItem
                 QRectF boundingRect() const { return m_rect; }
                 void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *) {}
             public:
-                void seriesChanged();
+                void updateGeometry();
-                void resize();
                 QRectF pieRect() const { return m_pieRect; }
             public Q_SLOTS:
+                void handleSeriesChanged(const PieChangeSet& changeSet);
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& rect);
             private:
                 friend class PieSlice;
                 QList<PieSlice*> m_slices;
                 QPieSeries *m_pieSeries;
                 QRectF m_rect;
                 QRectF m_pieRect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIEPRESENTER_H

src/piechart/pieslice.cpp +78 -45

@@ -1,91 +1,124
1	#include "pieslice.h"	1	#include "pieslice.h"
2	#include "piepresenter.h"	2	#include "piepresenter.h"
		3	#include "qpieseries.h"
3	#include <QPainter>	4	#include <QPainter>
4	#include <QDebug>	5	#include <QDebug>
		6	#include <qmath.h>
5		7
6	QTCOMMERCIALCHART_BEGIN_NAMESPACE	8	QTCOMMERCIALCHART_BEGIN_NAMESPACE
7		9
8	PieSlice::PieSlice(PiePresenter *piePresentation, int seriesIndex, qreal startAngle, qreal span)	10	#define PI 3.14159265
9	:QGraphicsItem(piePresentation),	11	#define EXPLODE_OFFSET 20
		12
		13	QPointF offset(qreal angle, qreal length)
		14	{
		15	qreal dx = qSin(angle(PI/180)) length;
		16	qreal dy = qCos(angle(PI/180)) length;
		17	return QPointF(dx, -dy);
		18	}
		19
		20	PieSlice::PieSlice(PiePresenter *presenter, int seriesIndex, qreal startAngle, qreal span)
		21	:QGraphicsItem(presenter),
		22	m_label(new QGraphicsTextItem(this)),
10	m_seriesIndex(seriesIndex),	23	m_seriesIndex(seriesIndex),
11	m_startAngle(startAngle),	24	m_startAngle(startAngle),
12	m_span(span)	25	m_span(span)
13	{	26	{
14	Q_ASSERT(p~~ieP~~resent~~ation~~);	27	Q_ASSERT(presenter);
15	setAcceptHoverEvents(true);	28	setAcceptHoverEvents(true);
16	setAcceptedMouseButtons(Qt::LeftButton);	29	setAcceptedMouseButtons(Qt::LeftButton);
		30	updateGeometry();
		31
		32	// TODO: use themes
		33	m_pen = QPen(Qt::black);
		34	m_brush = QBrush(sliceData().m_color);
17	}	35	}
18		36
19	PieSlice::~PieSlice()	37	PieSlice::~PieSlice()
20	{	38	{
21	}	39	}
22		40
23	QRectF PieSlice::boundingRect() const	41	QRectF PieSlice::boundingRect() const
24	{	42	{
25	return shape().boundingRect();	43	return m_rect;
26	}	44	}
27		45
28	QPainterPath PieSlice::shape() const	46	QPainterPath PieSlice::shape() const
29	{	47	{
30	QRectF rect = (static_cast<PiePresenter*>(parentItem()))->pieRect();	48	return m_path;
31	qreal angle = (-m_startAngle) + (90);
32	qreal span = -m_span;
33
34	QPainterPath path;
35	path.moveTo(rect.center());
36	path.arcTo(rect, angle, span);
37
38	// TODO: draw the shape so that it might have a hole in the center
39	// - Sin & Cos will be needed to find inner/outer arc endpoints
40
41	// dx, dy are offsets from the center
42	//qreal l = boundingRect().height();
43	//qreal dx = qSin(angle(M_PI/180)) l;
44	//qreal dy = qCos(angle(M_PI/180)) l;
45
46	// TODO: exploded slice?
47
48	return path;
49	}	49	}
50		50
51	void PieSlice::paint(QPainter* painter, const QStyleOptionGraphicsItem* /option/, QWidget* /widget/)	51	void PieSlice::paint(QPainter* painter, const QStyleOptionGraphicsItem* /option/, QWidget* /widget/)
52	{	52	{
53	painter->setRenderHint(QPainter::Antialiasing);	53	painter->setRenderHint(QPainter::Antialiasing);
54	// TODO: how to map theme settings to a pie slice? Now we
55	//painter->setPen(m_theme.linePen);
56	// TODO:
57
58	QPieSlice data = (static_cast<PiePresenter*>(parentItem()))->m_pieSeries->slice(m_seriesIndex);
59	painter->setBrush(data.m_color);
60		54
61		55	// TODO: themes
62	//painter->set~~Brush(m_theme.linePen.color()~~);	56	painter->setPen(m_pen);
63		57	painter->setBrush(m_brush);
64	// From Qt docs:	58	painter->drawPath(m_path);
65	// The startAngle and spanAngle must be specified in 1/16th of a degree, i.e. a full circle equals 5760 (16 * 360).
66	// Positive values for the angles mean counter-clockwise while negative values mean the clockwise direction.
67	// Zero degrees is at the 3 o'clock position.
68	//
69	// For sake of simplicity convert this so that zero degrees is at 12 o'clock and full circle is 360.
70	//qreal angle = (-m_startAngle16) + (9016);
71	//qreal span = -m_span*16;
72	//painter->drawPie(boundingRect(), angle, span);
73
74	painter->drawPath(shape());
75		59
76	// Draw the label	60	// Draw the label
77	// TODO: do this better	61	// TODO: do this better
78	painter->drawText(boundingRect().center(), data.m_label);	62	//QTextItem text;
		63	painter->drawText(m_center, sliceData().m_label);
79	}	64	}
80		65
81	void PieSlice::hoverEnterEvent(QGraphicsSceneHoverEvent * event)	66	void PieSlice::hoverEnterEvent(QGraphicsSceneHoverEvent * event)
82	{	67	{
83	QGraphicsItem::hoverEnterEvent(event);	68	QGraphicsItem::hoverEnterEvent(event);
84	qDebug() << "hover" << m_seriesIndex << m_startAngle << m_span;	69	m_brush = QBrush(sliceData().m_color.lighter());
		70	update();
		71	}
		72
		73	void PieSlice::hoverLeaveEvent(QGraphicsSceneHoverEvent * event)
		74	{
		75	QGraphicsItem::hoverLeaveEvent(event);
		76	m_brush = QBrush(sliceData().m_color);
		77	update();
85	}	78	}
86		79
87	void PieSlice::mousePressEvent(QGraphicsSceneMouseEvent *event)	80	void PieSlice::mousePressEvent(QGraphicsSceneMouseEvent *event)
88	{	81	{
89	QGraphicsItem::mousePressEvent(event);	82	QGraphicsItem::mousePressEvent(event);
		83	QPieSlice data = sliceData();
		84	data.m_isExploded = !data.m_isExploded;
		85	(static_cast<PiePresenter*>(parentItem()))->m_pieSeries->update(m_seriesIndex, data);
		86	}
		87
		88	void PieSlice::updateGeometry()
		89	{
		90	prepareGeometryChange();
		91
		92	PiePresenter presenter = static_cast<PiePresenter>(parentItem());
		93	QRectF rect = presenter->pieRect();
		94	rect.adjust(EXPLODE_OFFSET, EXPLODE_OFFSET, -EXPLODE_OFFSET ,-EXPLODE_OFFSET);
		95
		96	qreal centerAngle = m_startAngle + (m_span/2);
		97
		98	if (presenter->m_pieSeries->slice(m_seriesIndex).m_isExploded) {
		99	QPointF d = offset((centerAngle), EXPLODE_OFFSET);
		100	rect.translate(d.x(), d.y());
		101	}
		102
		103	qreal angle = (-m_startAngle) + (90);
		104	qreal span = -m_span;
		105
		106	QPainterPath path;
		107	path.moveTo(rect.center());
		108	path.arcTo(rect, angle, span);
		109
		110	// TODO: draw the shape so that it might have a hole in the center
		111
		112	m_path = path;
		113	m_rect = path.boundingRect();
		114
		115	qreal radius = rect.height() / 2;
		116	m_center = rect.center() + offset(centerAngle, radius / 2);
90	}	117	}
		118
		119	QPieSlice PieSlice::sliceData()
		120	{
		121	return (static_cast<PiePresenter*>(parentItem()))->m_pieSeries->slice(m_seriesIndex);
		122	}
		123
91	QTCOMMERCIALCHART_END_NAMESPACE	124	QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslice.h +15 -2

             #ifndef PIESLICE_H
             #define PIESLICE_H
             #include "qchartglobal.h"
             #include "charttheme_p.h"
+            #include "qpieseries.h"
             #include <QGraphicsItem>
             #include <QRectF>
             #include <QColor>
+            #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PiePresenter;
             class PieSlice : public QGraphicsItem
             {
             public:
-                PieSlice(PiePresenter *piePresentation, int seriesIndex, qreal startAngle, qreal span);
+                PieSlice(PiePresenter *piePresenter, 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 hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
+            public:
+                void updateGeometry();
+            private:
+                QPieSlice sliceData();
             private:
+                QGraphicsTextItem* m_label;
                 int m_seriesIndex;
                 qreal m_startAngle;
                 qreal m_span;
+                QPainterPath m_path;
                 QRectF m_rect;
-                //SeriesTheme m_theme;
+                QPointF m_center;
+                QPen m_pen;
+                QBrush m_brush;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICE_H

src/piechart/qpieseries.cpp +23 -29

             #include "qpieseries.h"
             #include "piepresenter.h"
             #include "pieslice.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QPieSeries::QPieSeries(QObject *parent) :
                 QChartSeries(parent),
-                m_piePresenter(0),
                 m_sizeFactor(1.0),
                 m_position(PiePositionMaximized)
             {
             }
             QPieSeries::~QPieSeries()
             {
             }
             void QPieSeries::set(QList<QPieSlice> slices)
             {
-                m_slices = slices;
+                PieChangeSet changeSet;
-                if (m_piePresenter) {
-                    m_piePresenter->seriesChanged();
+                for (int i=slices.count(); i<m_slices.count(); i++)
-                    m_piePresenter->update();
+                    changeSet.m_removed << i;
+                for (int i=0; i<slices.count(); i++) {
+                    if (i < m_slices.count())
+                        changeSet.m_changed << i;
+                    else
+                        changeSet.m_added << i;
                 }
+                m_slices = slices;
+                emit changed(changeSet);
             }
             void QPieSeries::add(QList<QPieSlice> slices)
             {
+                PieChangeSet changeSet;
+                for (int i=0; i<slices.count(); i++)
+                    changeSet.m_added << m_slices.count() + i;
                 m_slices += slices;
-                if (m_piePresenter) {
+                emit changed(changeSet);
-                    m_piePresenter->seriesChanged();
-                    // TODO: m_piePresenter->seriesAppended()??
-                    m_piePresenter->update();
             }
             void QPieSeries::add(QPieSlice slice)
             {
                 add(QList<QPieSlice>() << slice);
             }
             QPieSlice QPieSeries::slice(int index) const
             {
                 if ((index >= 0) && (index < m_slices.count()))
                     return m_slices.at(index);
                 return QPieSlice();
             }
             bool QPieSeries::update(int index, QPieSlice slice)
             {
                 if ((index >= 0) && (index < m_slices.count())) {
                     m_slices[index] = slice;
-                    if (m_piePresenter) {
+                    PieChangeSet changeSet;
-                        m_piePresenter->seriesChanged();
+                    changeSet.m_changed << index;
-                        // TODO: for a nice animation we need something like
+                    emit changed(changeSet);
-                        // m_piePresenter->sliceChanged(index, oldslice, newslice)
-                        m_piePresenter->update();
                     return true;
                 }
                 return false;
             }
             void QPieSeries::setSizeFactor(qreal factor)
             {
                 if (factor > 0.0)
                     m_sizeFactor = factor;
+                emit sizeFactorChanged();
-                if (m_piePresenter) {
-                    m_piePresenter->resize();
-                    m_piePresenter->update();
-                    // TODO: do we have to update the parent item also?
-                    //  - potential issue: what if this function is called from the parent context?
             }
             void QPieSeries::setPosition(PiePosition position)
             {
                 m_position = position;
-                if (m_piePresenter) {
+                emit positionChanged();
-                    m_piePresenter->resize();
-                    m_piePresenter->update();
-                    // TODO: do we have to update the parent item also?
-                    //  - potential issue: what if this function is called from the parent context?
             }
             #include "moc_qpieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.h +13 -4

             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include "qchartseries.h"
             #include <QObject>
             #include <QRectF>
             #include <QColor>
             class QGraphicsObject;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PiePresenter;
             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 PieChangeSet
+            {
+            public:
+                QList<int> m_added;
+                QList<int> m_removed;
+                QList<int> m_changed;
+            };
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
                 enum PiePosition {
                     PiePositionMaximized = 0,
                     PiePositionTopLeft,
                     PiePositionTopRight,
                     PiePositionBottomLeft,
                     PiePositionBottomRight
                 };
             public:
                 QPieSeries(QObject *parent = 0);
                 ~QPieSeries();
             public: // from QChartSeries
                 QChartSeriesType type() const { return QChartSeries::SeriesTypePie; }
             public:
                 void set(QList<QPieSlice> slices);
                 void add(QList<QPieSlice> slices);
                 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() const { return m_sizeFactor; }
                 void setPosition(PiePosition position);
                 PiePosition position() const { return m_position; }
+            Q_SIGNALS:
+                void changed(const PieChangeSet& changeSet);
+                void sizeFactorChanged();
+                void positionChanged();
             private:
                 Q_DISABLE_COPY(QPieSeries)
                 // TODO: use PIML
-                friend class ChartPresenter;
-                friend class ChartDataSet;
-                friend class PiePresenter;
-                PiePresenter *m_piePresenter;
                 QList<QPieSlice> m_slices;
                 qreal m_sizeFactor;
                 PiePosition m_position;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

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