HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r691:02b456949de5

Fix setting custom color to pie. Now the pie knows if the color is set by the user.

Jani Honkonen -

r691:02b456949de5

parent child

Context file:

r691:02b456949de5

Collapse all files

src/charttheme.cpp +18 -8

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

src/piechart/piechartitem.cpp +2 -3

             #include "piechartitem_p.h"
             #include "piesliceitem_p.h"
             #include "qpieslice.h"
             #include "qpiesliceprivate_p.h"
             #include "qpieseries.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "chartanimator_p.h"
             #include <QDebug>
             #include <QPainter>
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter* presenter)
                 :ChartItem(presenter),
                 m_series(series)
             {
                 Q_ASSERT(series);
                 connect(series, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
                 connect(series, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
                 connect(series, SIGNAL(piePositionChanged()), this, SLOT(handlePieLayoutChanged()));
                 connect(series, SIGNAL(pieSizeChanged()), this, SLOT(handlePieLayoutChanged()));
                 QTimer::singleShot(0, this, SLOT(initialize()));
                 // Note: the following does not affect as long as the item does not have anything to paint
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieChartItem::~PieChartItem()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PieChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
             {
                 Q_UNUSED(painter)
                 // TODO: paint shadows for all components
                 // - get paths from items & merge & offset and draw with shadow color?
                 //painter->setBrush(QBrush(Qt::red));
                 //painter->drawRect(m_debugRect);
             }
             void PieChartItem::initialize()
             {
                 handleSlicesAdded(m_series->slices());
             }
             void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
             {
                 bool isEmpty = m_slices.isEmpty();
-                presenter()->theme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
+                presenter()->theme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series), false);
                 foreach (QPieSlice *s, slices) {
                     PieSliceItem* item = new PieSliceItem(this);
                     m_slices.insert(s, item);
                     connect(s, SIGNAL(changed()), this, SLOT(handleSliceChanged()));
                     connect(item, SIGNAL(clicked()), s, SIGNAL(clicked()));
                     connect(item, SIGNAL(hoverEnter()), s, SIGNAL(hoverEnter()));
                     connect(item, SIGNAL(hoverLeave()), s, SIGNAL(hoverLeave()));
                     PieSliceData data = sliceData(s);
                     if (animator())
                         animator()->addAnimation(this, s, data, isEmpty);
                     else
                         setLayout(s, data);
                 }
             }
             void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices)
             {
-                presenter()->theme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
+                presenter()->theme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series), false);
                 foreach (QPieSlice *s, slices) {
                     if (animator())
                         animator()->removeAnimation(this, s);
                     else
                         destroySlice(s);
                 }
             }
             void PieChartItem::handlePieLayoutChanged()
             {
                 PieLayout layout = calculateLayout();
                 applyLayout(layout);
                 update();
             }
             void PieChartItem::handleSliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 PieSliceData data = sliceData(slice);
                 updateLayout(slice, data);
                 update();
             }
             void PieChartItem::handleDomainChanged(qreal, qreal, qreal, qreal)
             {
                 // TODO
             }
             void PieChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 handlePieLayoutChanged();
             }
             void PieChartItem::calculatePieLayout()
             {
                 // find pie center coordinates
                 m_pieCenter.setX(m_rect.left() + (m_rect.width() * m_series->pieHorizontalPosition()));
                 m_pieCenter.setY(m_rect.top() + (m_rect.height() * m_series->pieVerticalPosition()));
                 // find maximum radius for pie
                 m_pieRadius = m_rect.height() / 2;
                 if (m_rect.width() < m_rect.height())
                     m_pieRadius = m_rect.width() / 2;
                 // apply size factor
                 m_pieRadius *= m_series->pieSize();
             }
             PieSliceData PieChartItem::sliceData(QPieSlice *slice)
             {
                 PieSliceData sliceData = slice->data_ptr()->m_data;
                 sliceData.m_center = PieSliceItem::sliceCenter(m_pieCenter, m_pieRadius, slice);
                 sliceData.m_radius = m_pieRadius;
-                sliceData.m_angleSpan = slice->endAngle() - slice->startAngle();
                 return sliceData;
             }
             PieLayout PieChartItem::calculateLayout()
             {
                 calculatePieLayout();
                 PieLayout layout;
                 foreach (QPieSlice* s, m_series->slices()) {
                     if (m_slices.contains(s)) // calculate layout only for those slices that are already visible
                         layout.insert(s, sliceData(s));
                 }
                 return layout;
             }
             void PieChartItem::applyLayout(const PieLayout &layout)
             {
                 if (animator())
                     animator()->updateLayout(this, layout);
                 else
                     setLayout(layout);
             }
             void PieChartItem::updateLayout(QPieSlice *slice, const PieSliceData &sliceData)
             {
                 if (animator())
                     animator()->updateLayout(this, slice, sliceData);
                 else
                     setLayout(slice, sliceData);
             }
             void PieChartItem::setLayout(const PieLayout &layout)
             {
                 foreach (QPieSlice *slice, layout.keys()) {
                     PieSliceItem *item = m_slices.value(slice);
                     Q_ASSERT(item);
                     item->setSliceData(layout.value(slice));
                     item->updateGeometry();
                     item->update();
                 }
             }
             void PieChartItem::setLayout(QPieSlice *slice, const PieSliceData &sliceData)
             {
                 // find slice
                 PieSliceItem *item = m_slices.value(slice);
                 Q_ASSERT(item);
                 item->setSliceData(sliceData);
                 item->updateGeometry();
                 item->update();
             }
             void PieChartItem::destroySlice(QPieSlice *slice)
             {
                 delete m_slices.take(slice);
             }
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslicedata_p.h +71 -9

@@ -1,48 +1,110
1	#ifndef PIESLICEDATA_P_H	1	#ifndef PIESLICEDATA_P_H
2	#define PIESLICEDATA_P_H	2	#define PIESLICEDATA_P_H
3		3
4	#include <qchartglobal.h>	4	#include <qchartglobal.h>
5	#include <QPen>	5	#include <QPen>
6	#include <QBrush>	6	#include <QBrush>
		7	#include <QDebug>
7		8
8	QTCOMMERCIALCHART_BEGIN_NAMESPACE	9	QTCOMMERCIALCHART_BEGIN_NAMESPACE
9		10
		11	template <class T>
		12	class Themed : public T
		13	{
		14	public:
		15	Themed():m_isThemed(true) {}
		16
		17	inline T &operator=(const T &other) { return T::operator =(other); }
		18
		19	inline bool operator!=(const T &other) { return T::operator !=(other); }
		20	inline bool operator!=(const Themed &other)
		21	{
		22	if (T::operator !=(other))
		23	return true;
		24
		25	if (m_isThemed != other.m_isThemed)
		26	return true;
		27
		28	return false;
		29	}
		30
		31	inline void setThemed(bool state) { m_isThemed = state; }
		32	inline bool isThemed() const { return m_isThemed; }
		33
		34	private:
		35	bool m_isThemed;
		36	};
		37
10	class PieSliceData	38	class PieSliceData
11	{	39	{
12	public:	40	public:
13	PieSliceData()	41	PieSliceData()
14	{	42	{
15	m_value = 0;	43	m_value = 0;
16	m_percentage = 0;	44
17	m_startAngle = 0;
18	m_angleSpan = 0;
19	m_isExploded = false;	45	m_isExploded = false;
20	m_explodeDistanceFactor = 0.15;	46	m_explodeDistanceFactor = 0.15;
21	m_labelVisible = false;	47
		48	m_isLabelVisible = false;
22	m_labelArmLengthFactor = 0.15;	49	m_labelArmLengthFactor = 0.15;
		50
		51	m_percentage = 0;
		52	m_radius = 0;
		53	m_startAngle = 0;
		54	m_angleSpan = 0;
		55	}
		56
		57	bool operator!=(const PieSliceData &other)
		58	{
		59	if (m_value != other.m_value)
		60	return true;
		61
		62	if (m_slicePen != other.m_slicePen \|\|
		63	m_sliceBrush != other.m_sliceBrush)
		64	return true;
		65
		66	if (m_isExploded != other.m_isExploded \|\|
		67	m_explodeDistanceFactor != other.m_explodeDistanceFactor)
		68	return true;
		69
		70	if (m_isLabelVisible != other.m_isLabelVisible \|\|
		71	m_labelText != other.m_labelText \|\|
		72	m_labelFont != other.m_labelFont \|\|
		73	m_labelArmLengthFactor != other.m_labelArmLengthFactor \|\|
		74	m_labelArmPen != other.m_labelArmPen)
		75	return true;
		76
		77	if (m_percentage != other.m_percentage \|\|
		78	m_center != other.m_center \|\|
		79	m_radius != other.m_radius \|\|
		80	m_startAngle != other.m_startAngle \|\|
		81	m_angleSpan != other.m_angleSpan)
		82	return true;
		83
		84	return false;
23	}	85	}
24		86
25	qreal m_value;	87	qreal m_value;
26		88
27	QPen m_slicePen;	89	Themed<QPen> m_slicePen;
28	QBrush m_sliceBrush;	90	Themed<QBrush> m_sliceBrush;
29		91
30	bool m_isExploded;	92	bool m_isExploded;
31	qreal m_explodeDistanceFactor;	93	qreal m_explodeDistanceFactor;
32		94
33	bool m_labelVisible;	95	bool m_isLabelVisible;
34	QString m_labelText;	96	QString m_labelText;
35	QFont m_labelFont;	97	Themed<QFont> m_labelFont;
36	qreal m_labelArmLengthFactor;	98	qreal m_labelArmLengthFactor;
37	QPen m_labelArmPen;	99	Themed<QPen> m_labelArmPen;
38		100
39	qreal m_percentage;	101	qreal m_percentage;
40	QPointF m_center;	102	QPointF m_center;
41	qreal m_radius;	103	qreal m_radius;
42	qreal m_startAngle;	104	qreal m_startAngle;
43	qreal m_angleSpan;	105	qreal m_angleSpan;
44	};	106	};
45		107
46	QTCOMMERCIALCHART_END_NAMESPACE	108	QTCOMMERCIALCHART_END_NAMESPACE
47		109
48	#endif // PIESLICEDATA_P_H	110	#endif // PIESLICEDATA_P_H

src/piechart/piesliceitem.cpp +1 -1

             #include "piesliceitem_p.h"
             #include "piechartitem_p.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QDebug>
             #include <qmath.h>
             #include <QGraphicsSceneEvent>
             #include <QTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             #define PI 3.14159265 // TODO: is this defined in some header?
             QPointF offset(qreal angle, qreal length)
             {
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = qCos(angle*(PI/180)) * length;
                 return QPointF(dx, -dy);
             }
             PieSliceItem::PieSliceItem(QGraphicsItem* parent)
                 :QGraphicsObject(parent)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::LeftButton);
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieSliceItem::~PieSliceItem()
             {
             }
             QRectF PieSliceItem::boundingRect() const
             {
                 return m_boundingRect;
             }
             QPainterPath PieSliceItem::shape() const
             {
                 // Don't include the label and label arm.
                 // This is used to detect a mouse clicks. We do not want clicks from label.
                 return m_slicePath;
             }
             void PieSliceItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->setClipRect(parentItem()->boundingRect());
                 painter->save();
                 painter->setPen(m_data.m_slicePen);
                 painter->setBrush(m_data.m_sliceBrush);
                 painter->drawPath(m_slicePath);
                 painter->restore();
-                if (m_data.m_labelVisible) {
+                if (m_data.m_isLabelVisible) {
                     painter->save();
                     painter->setPen(m_data.m_labelArmPen);
                     painter->drawPath(m_labelArmPath);
                     painter->restore();
                     painter->setFont(m_data.m_labelFont);
                     painter->drawText(m_labelTextRect.bottomLeft(), m_data.m_labelText);
                 }
             }
             void PieSliceItem::hoverEnterEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverEnter();
             }
             void PieSliceItem::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverLeave();
             }
             void PieSliceItem::mousePressEvent(QGraphicsSceneMouseEvent* /*event*/)
             {
                 emit clicked();
             }
             void PieSliceItem::setSliceData(PieSliceData sliceData)
             {
                 m_data = sliceData;
             }
             void PieSliceItem::updateGeometry()
             {
                 if (m_data.m_radius <= 0)
                     return;
                 prepareGeometryChange();
                 // update slice path
                 qreal centerAngle;
                 QPointF armStart;
                 m_slicePath = slicePath(m_data.m_center, m_data.m_radius, m_data.m_startAngle, m_data.m_angleSpan, &centerAngle, &armStart);
                 // update text rect
                 m_labelTextRect = labelTextRect(m_data.m_labelFont, m_data.m_labelText);
                 // update label arm path
                 QPointF labelTextStart;
                 m_labelArmPath = labelArmPath(armStart, centerAngle, m_data.m_radius * m_data.m_labelArmLengthFactor, m_labelTextRect.width(), &labelTextStart);
                 // update text position
                 m_labelTextRect.moveBottomLeft(labelTextStart);
                 // update bounding rect
                 m_boundingRect = m_slicePath.boundingRect().united(m_labelArmPath.boundingRect()).united(m_labelTextRect);
             }
             QPointF PieSliceItem::sliceCenter(QPointF point, qreal radius, QPieSlice *slice)
             {
                 if (slice->isExploded()) {
                     qreal centerAngle = slice->startAngle() + ((slice->endAngle() - slice->startAngle())/2);
                     qreal len = radius * slice->explodeDistanceFactor();
                     qreal dx = qSin(centerAngle*(PI/180)) * len;
                     qreal dy = -qCos(centerAngle*(PI/180)) * len;
                     point += QPointF(dx, dy);
                 }
                 return point;
             }
             QPainterPath PieSliceItem::slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal* centerAngle, QPointF* armStart)
             {
                 // calculate center angle
                 *centerAngle = startAngle + (angleSpan/2);
                 // calculate slice rectangle
                 QRectF rect(center.x()-radius, center.y()-radius, radius*2, radius*2);
                 // slice path
                 // TODO: draw the shape so that it might have a hole in the center
                 QPainterPath path;
                 path.moveTo(rect.center());
                 path.arcTo(rect, -startAngle + 90, -angleSpan);
                 path.closeSubpath();
                 // calculate label arm start point
                 *armStart = center;
                 *armStart += offset(*centerAngle, radius + PIESLICE_LABEL_GAP);
                 return path;
             }
             QPainterPath PieSliceItem::labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF* textStart)
             {
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = -qCos(angle*(PI/180)) * length;
                 QPointF parm1 = start + QPointF(dx, dy);
                 QPointF parm2 = parm1;
                 if (angle < 180) { // arm swings the other way on the left side
                      parm2 += QPointF(textWidth, 0);
                      *textStart = parm1;
                 }
                 else {
                      parm2 += QPointF(-textWidth,0);
                      *textStart = parm2;
                 }
                 // elevate the text position a bit so that it does not hit the line
                 *textStart += QPointF(0, -5);
                 QPainterPath path;
                 path.moveTo(start);
                 path.lineTo(parm1);
                 path.lineTo(parm2);
                 return path;
             }
             QRectF PieSliceItem::labelTextRect(QFont font, QString text)
             {
                 QFontMetricsF fm(font);
                 return fm.boundingRect(text);
             }
             #include "moc_piesliceitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieslice.cpp +9 -5

             #include "qpieslice.h"
             #include "qpiesliceprivate_p.h"
             #include "qpieseries.h"
             #include "qpieseriesprivate_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSlice
                 \brief Defines a slice in pie series.
                 Holds all the data of a single slice in a QPieSeries and provides the means
                 to modify slice data and customize the visual appearance of the slice.
                 It also provides the means to customize user interaction with the slice by
                 providing signals for clicking and hover events.
             */
             /*!
                 \property QPieSlice::label
                 Label of the slice.
             */
             /*!
                 \property QPieSlice::value
                 Value of the slice.
             */
             /*!
                 Constructs an empty slice with a \a parent.
                 Note that QPieSeries takes ownership of the slice when it is set/added.
                 \sa QPieSeries::replace(), QPieSeries::add()
             */
             QPieSlice::QPieSlice(QObject *parent)
                 :QObject(parent),
                 d_ptr(new QPieSlicePrivate(this))
             {
             }
             /*!
                 Constructs an empty slice with given \a value, \a label and a \a parent.
                 Note that QPieSeries takes ownership of the slice when it is set/added.
                 \sa QPieSeries::replace(), QPieSeries::add()
             */
             QPieSlice::QPieSlice(qreal value, QString label, QObject *parent)
                 :QObject(parent),
                 d_ptr(new QPieSlicePrivate(this))
             {
                 Q_D(QPieSlice);
                 d->m_data.m_value = value;
                 d->m_data.m_labelText = label;
             }
             /*!
                 Destroys the slice.
                 User should not delete the slice if it has been added to the series.
             */
             QPieSlice::~QPieSlice()
             {
                 delete d_ptr;
             }
             /*!
                 Gets the value of the slice.
                 Note that all values in the series
                 \sa setValue()
             */
             qreal QPieSlice::value() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_value;
             }
             /*!
                 Gets the label of the slice.
                 \sa setLabel()
             */
             QString QPieSlice::label() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_labelText;
             }
             /*!
                 Returns true if label is set as visible.
                 \sa setLabelVisible()
             */
             bool QPieSlice::isLabelVisible() const
             {
                 Q_D(const QPieSlice);
-                return d->m_data.m_labelVisible;
+                return d->m_data.m_isLabelVisible;
             }
             /*!
                 Returns true if slice is exloded from the pie.
                 \sa setExploded(), setExplodeDistanceFactor()
             */
             bool QPieSlice::isExploded() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_isExploded;
             }
             /*!
                 Returns the explode distance factor.
                 The factor is relative to pie radius. For example:
 .0 means the distance is the same as the radius.
 .5 means the distance is half of the radius.
                 Default value is 0.15.
                 \sa setExplodeDistanceFactor()
             */
             qreal QPieSlice::explodeDistanceFactor() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_explodeDistanceFactor;
             }
             /*!
                 Returns the percentage of this slice compared to all slices in the same series.
                 The returned value ranges from 0 to 1.0.
                 Updated internally after the slice is added to the series.
             */
             qreal QPieSlice::percentage() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_percentage;
             }
             /*!
                 Returns the starting angle of this slice in the series it belongs to.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated internally after the slice is added to the series.
             */
             qreal QPieSlice::startAngle() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_startAngle;
             }
             /*!
                 Returns the end angle of this slice in the series it belongs to.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated internally after the slice is added to the series.
             */
             qreal QPieSlice::endAngle() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_startAngle + d->m_data.m_angleSpan;
             }
             /*!
                 Returns the pen used to draw this slice.
                 \sa setSlicePen()
             */
             QPen QPieSlice::slicePen() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_slicePen;
             }
             /*!
                 Returns the brush used to draw this slice.
                 \sa setSliceBrush()
             */
             QBrush QPieSlice::sliceBrush() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_sliceBrush;
             }
             /*!
                 Returns the pen used to draw label arm in this slice.
                 \sa setLabelArmPen()
             */
             QPen QPieSlice::labelArmPen() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_labelArmPen;
             }
             /*!
                 Returns the font used to draw label in this slice.
                 \sa setLabelFont()
             */
             QFont QPieSlice::labelFont() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_labelFont;
             }
             /*!
-                Gets the label arm lenght factor.
+                Gets the label arm length factor.
                 The factor is relative to pie radius. For example:
 .0 means the length is the same as the radius.
 .5 means the length is half of the radius.
                 Default value is 0.15
                 \sa setLabelArmLengthFactor()
             */
             qreal QPieSlice::labelArmLengthFactor() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_labelArmLengthFactor;
             }
             /*!
                 \fn void QPieSlice::clicked()
                 This signal is emitted when user has clicked the slice.
                 \sa QPieSeries::clicked()
             */
             /*!
                 \fn void QPieSlice::hoverEnter()
                 This signal is emitted when user has hovered over the slice.
                 \sa QPieSeries::hoverEnter()
             */
             /*!
                 \fn void QPieSlice::hoverLeave()
                 This signal is emitted when user has hovered away from the slice.
                 \sa QPieSeries::hoverLeave()
             */
             /*!
                 \fn void QPieSlice::changed()
                 This signal emitted when something has changed in the slice.
                 \sa QPieSeries::changed()
             */
             /*!
                 Sets the \a value of this slice.
                 \sa value()
             */
             void QPieSlice::setValue(qreal value)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_value != value) {
                     d->m_data.m_value = value;
                     QPieSeries *series = qobject_cast<QPieSeries*>(parent());
                     if (series)
                         series->data_ptr()->updateDerivativeData(); // will emit changed()
                     else
                         emit changed();
                 }
             }
             /*!
                 Sets the \a label of the slice.
                 \sa label()
             */
             void QPieSlice::setLabel(QString label)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_labelText != label) {
                     d->m_data.m_labelText = label;
                     emit changed();
                 }
             }
             /*!
                 Sets the label \a visible in this slice.
                 \sa isLabelVisible(), QPieSeries::setLabelsVisible()
             */
             void QPieSlice::setLabelVisible(bool visible)
             {
                 Q_D(QPieSlice);
-                if (d->m_data.m_labelVisible != visible) {
+                if (d->m_data.m_isLabelVisible != visible) {
-                    d->m_data.m_labelVisible = visible;
+                    d->m_data.m_isLabelVisible = visible;
                     emit changed();
                 }
             }
             /*!
                 Sets this slice \a exploded.
                 \sa isExploded(), explodeDistanceFactor()
             */
             void QPieSlice::setExploded(bool exploded)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_isExploded != exploded) {
                     d->m_data.m_isExploded = exploded;
                     emit changed();
                 }
             }
             /*!
                 Sets the explode distance \a factor.
                 The factor is relative to pie radius. For example:
 .0 means the distance is the same as the radius.
 .5 means the distance is half of the radius.
                 Default value is 0.15
                 \sa explodeDistanceFactor()
             */
             void QPieSlice::setExplodeDistanceFactor(qreal factor)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_explodeDistanceFactor != factor) {
                     d->m_data.m_explodeDistanceFactor = factor;
                     emit changed();
                 }
             }
             /*!
                 Sets the \a pen used to draw this slice.
                 Note that applying a theme will override this.
                 \sa slicePen()
             */
             void QPieSlice::setSlicePen(const QPen &pen)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_slicePen != pen) {
                     d->m_data.m_slicePen = pen;
+                    d->m_data.m_slicePen.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the \a brush used to draw this slice.
                 Note that applying a theme will override this.
                 \sa sliceBrush()
             */
             void QPieSlice::setSliceBrush(const QBrush &brush)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_sliceBrush != brush) {
                     d->m_data.m_sliceBrush = brush;
+                    d->m_data.m_sliceBrush.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the \a pen used to draw the label arm in this slice.
                 Note that applying a theme will override this.
                 \sa labelArmPen()
             */
             void QPieSlice::setLabelArmPen(const QPen &pen)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_labelArmPen != pen) {
                     d->m_data.m_labelArmPen = pen;
+                    d->m_data.m_labelArmPen.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the \a font used to draw the label in this slice.
                 Note that applying a theme will override this.
                 \sa labelFont()
             */
             void QPieSlice::setLabelFont(const QFont &font)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_labelFont != font) {
                     d->m_data.m_labelFont = font;
+                    d->m_data.m_labelFont.setThemed(false);
                     emit changed();
                 }
             }
             /*!
-                Sets the label arm lenght \a factor.
+                Sets the label arm length \a factor.
                 The factor is relative to pie radius. For example:
 .0 means the length is the same as the radius.
 .5 means the length is half of the radius.
                 Default value is 0.15
                 \sa labelArmLengthFactor()
             */
             void QPieSlice::setLabelArmLengthFactor(qreal factor)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_labelArmLengthFactor != factor) {
                     d->m_data.m_labelArmLengthFactor = factor;
                     emit changed();
                 }
             }
             #include "moc_qpieslice.cpp"
             #include "moc_qpiesliceprivate_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpiesliceprivate_p.h +1 0

             #ifndef QPIESLICEPRIVATE_P_H
             #define QPIESLICEPRIVATE_P_H
             #include "qpieslice.h"
             #include "pieslicedata_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSlicePrivate : public QObject
             {
                 Q_OBJECT
                 Q_DECLARE_PUBLIC(QPieSlice)
             public:
                 QPieSlicePrivate(QPieSlice *parent)
                     :QObject(parent),
                     q_ptr(parent)
                 {
                     connect(this, SIGNAL(changed()), q_ptr, SIGNAL(changed()));
                 }
                 ~QPieSlicePrivate() {}
             Q_SIGNALS:
                 void changed();
             public:
                 friend class QPieSeriesPrivate;
+                friend class ChartTheme;
                 QPieSlice * const q_ptr;
                 PieSliceData m_data;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESLICEPRIVATE_P_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