|
|
#include "qpieseries.h"
|
|
|
#include "qpieslice.h"
|
|
|
#include <QDebug>
|
|
|
|
|
|
QTCOMMERCIALCHART_BEGIN_NAMESPACE
|
|
|
|
|
|
|
|
|
/*!
|
|
|
\class QPieSeries::ChangeSet
|
|
|
\brief Defines the changes in the series.
|
|
|
|
|
|
Contains the changes that have occurred in the series. Lists of added, changed and removed slices.
|
|
|
|
|
|
\sa QPieSeries::changed()
|
|
|
*/
|
|
|
|
|
|
/*!
|
|
|
\internal
|
|
|
*/
|
|
|
void QPieSeries::ChangeSet::appendAdded(QPieSlice* slice)
|
|
|
{
|
|
|
if (!m_added.contains(slice))
|
|
|
m_added << slice;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
\internal
|
|
|
*/
|
|
|
void QPieSeries::ChangeSet::appendAdded(QList<QPieSlice*> slices)
|
|
|
{
|
|
|
foreach (QPieSlice* s, slices)
|
|
|
appendAdded(s);
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
\internal
|
|
|
*/
|
|
|
void QPieSeries::ChangeSet::appendChanged(QPieSlice* slice)
|
|
|
{
|
|
|
if (!m_changed.contains(slice))
|
|
|
m_changed << slice;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
\internal
|
|
|
*/
|
|
|
void QPieSeries::ChangeSet::appendRemoved(QPieSlice* slice)
|
|
|
{
|
|
|
if (!m_removed.contains(slice))
|
|
|
m_removed << slice;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Returns a list of slices that have been added to the series.
|
|
|
\sa QPieSeries::changed()
|
|
|
*/
|
|
|
QList<QPieSlice*> QPieSeries::ChangeSet::added() const
|
|
|
{
|
|
|
return m_added;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Returns a list of slices that have been changed in the series.
|
|
|
\sa QPieSeries::changed()
|
|
|
*/
|
|
|
QList<QPieSlice*> QPieSeries::ChangeSet::changed() const
|
|
|
{
|
|
|
return m_changed;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Returns a list of slices that have been removed from the series.
|
|
|
\sa QPieSeries::changed()
|
|
|
*/
|
|
|
QList<QPieSlice*> QPieSeries::ChangeSet::removed() const
|
|
|
{
|
|
|
return m_removed;
|
|
|
}
|
|
|
|
|
|
|
|
|
/*!
|
|
|
Returns true if there are no added/changed or removed slices in the change set.
|
|
|
*/
|
|
|
bool QPieSeries::ChangeSet::isEmpty() const
|
|
|
{
|
|
|
if (m_added.count() || m_changed.count() || m_removed.count())
|
|
|
return false;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
\enum QPieSeries::PiePosition
|
|
|
|
|
|
This enum describes pie position within its bounding rectangle
|
|
|
|
|
|
\value PiePositionMaximized
|
|
|
\value PiePositionTopLeft
|
|
|
\value PiePositionTopRight
|
|
|
\value PiePositionBottomLeft
|
|
|
\value PiePositionBottomRight
|
|
|
*/
|
|
|
|
|
|
/*!
|
|
|
\class QPieSeries
|
|
|
\brief Pie series API for QtCommercial Charts
|
|
|
|
|
|
The pie series defines a pie chart which consists of pie slices which are QPieSlice objects.
|
|
|
The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
|
|
|
The actual slice size (span) is determined by that relative value.
|
|
|
|
|
|
By default the pie is defined as full but it can be a partial pie.
|
|
|
This can be done by setting a starting angle and angle span to the series.
|
|
|
|
|
|
Example on how to create a chart with pie series:
|
|
|
\snippet ../example/piechart/main.cpp 1
|
|
|
|
|
|
To help with the most common user intercation scenarions there some convenience functions. Specifically
|
|
|
exploding and higlighting:
|
|
|
\snippet ../example/piechart/main.cpp 2
|
|
|
|
|
|
*/
|
|
|
|
|
|
/*!
|
|
|
Constructs a series object which is a child of \a parent.
|
|
|
*/
|
|
|
QPieSeries::QPieSeries(QObject *parent) :
|
|
|
QChartSeries(parent),
|
|
|
m_sizeFactor(1.0),
|
|
|
m_position(PiePositionMaximized),
|
|
|
m_pieStartAngle(0),
|
|
|
m_pieAngleSpan(360)
|
|
|
{
|
|
|
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
|
|
|
*/
|
|
|
QPieSeries::~QPieSeries()
|
|
|
{
|
|
|
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Returns QChartSeries::SeriesTypePie.
|
|
|
*/
|
|
|
QChartSeries::QChartSeriesType QPieSeries::type() const
|
|
|
{
|
|
|
return QChartSeries::SeriesTypePie;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
\internal \a data
|
|
|
*/
|
|
|
bool QPieSeries::setData(QList<qreal> data)
|
|
|
{
|
|
|
// TODO: remove this function
|
|
|
QList<QPieSlice*> slices;
|
|
|
foreach (qreal value, data)
|
|
|
slices << new QPieSlice(value, QString::number(value));
|
|
|
replace(slices);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Sets an array of \a slices to the series replacing the existing slices.
|
|
|
Slice ownership is passed to the series.
|
|
|
*/
|
|
|
void QPieSeries::replace(QList<QPieSlice*> slices)
|
|
|
{
|
|
|
clear();
|
|
|
add(slices);
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Adds an array of \a slices to the series.
|
|
|
Slice ownership is passed to the series.
|
|
|
*/
|
|
|
void QPieSeries::add(QList<QPieSlice*> slices)
|
|
|
{
|
|
|
ChangeSet changeSet;
|
|
|
foreach (QPieSlice* s, slices) {
|
|
|
s->setParent(this);
|
|
|
m_slices << s;
|
|
|
changeSet.appendAdded(s);
|
|
|
}
|
|
|
|
|
|
updateDerivativeData();
|
|
|
|
|
|
foreach (QPieSlice* s, slices) {
|
|
|
connect(s, SIGNAL(changed()), this, SLOT(sliceChanged()));
|
|
|
connect(s, SIGNAL(clicked()), this, SLOT(sliceClicked()));
|
|
|
connect(s, SIGNAL(hoverEnter()), this, SLOT(sliceHoverEnter()));
|
|
|
connect(s, SIGNAL(hoverLeave()), this, SLOT(sliceHoverLeave()));
|
|
|
}
|
|
|
|
|
|
emit changed(changeSet);
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Adds a single \a slice to the series.
|
|
|
Slice ownership is passed to the series.
|
|
|
*/
|
|
|
void QPieSeries::add(QPieSlice* slice)
|
|
|
{
|
|
|
add(QList<QPieSlice*>() << slice);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*!
|
|
|
Adds a single slice to the series with give \a value and \a name.
|
|
|
Slice ownership is passed to the series.
|
|
|
*/
|
|
|
QPieSlice* QPieSeries::add(qreal value, QString name)
|
|
|
{
|
|
|
QPieSlice* slice = new QPieSlice(value, name);
|
|
|
add(slice);
|
|
|
return slice;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Removes a single \a slice from the series and deletes the slice.
|
|
|
|
|
|
Do not reference this pointer after this call.
|
|
|
*/
|
|
|
void QPieSeries::remove(QPieSlice* slice)
|
|
|
{
|
|
|
if (!m_slices.removeOne(slice)) {
|
|
|
Q_ASSERT(0); // TODO: how should this be reported?
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
ChangeSet changeSet;
|
|
|
changeSet.appendRemoved(slice);
|
|
|
emit changed(changeSet);
|
|
|
|
|
|
delete slice;
|
|
|
slice = NULL;
|
|
|
|
|
|
updateDerivativeData();
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Clears all slices from the series.
|
|
|
*/
|
|
|
void QPieSeries::clear()
|
|
|
{
|
|
|
if (m_slices.count() == 0)
|
|
|
return;
|
|
|
|
|
|
ChangeSet changeSet;
|
|
|
foreach (QPieSlice* s, m_slices) {
|
|
|
changeSet.appendRemoved(s);
|
|
|
m_slices.removeOne(s);
|
|
|
delete s;
|
|
|
}
|
|
|
emit changed(changeSet);
|
|
|
updateDerivativeData();
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Counts the number of the slices in this series.
|
|
|
*/
|
|
|
int QPieSeries::count() const
|
|
|
{
|
|
|
return m_slices.count();
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Returns a list of slices that belong to this series.
|
|
|
*/
|
|
|
QList<QPieSlice*> QPieSeries::slices() const
|
|
|
{
|
|
|
return m_slices;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Sets the size \a factor of the pie. 1.0 is the default value.
|
|
|
Note that the pie will not grow beyond its absolute maximum size.
|
|
|
In practice its use is to make the pie appear smaller.
|
|
|
\sa sizeFactor()
|
|
|
*/
|
|
|
void QPieSeries::setSizeFactor(qreal factor)
|
|
|
{
|
|
|
if (factor < 0.0)
|
|
|
return;
|
|
|
|
|
|
if (m_sizeFactor != factor) {
|
|
|
m_sizeFactor = factor;
|
|
|
emit sizeFactorChanged();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Gets the size factor of the pie.
|
|
|
\sa setSizeFactor()
|
|
|
*/
|
|
|
qreal QPieSeries::sizeFactor() const
|
|
|
{
|
|
|
return m_sizeFactor;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Sets the \a position of the pie within its bounding rectangle.
|
|
|
\sa PiePosition, position()
|
|
|
*/
|
|
|
void QPieSeries::setPosition(PiePosition position)
|
|
|
{
|
|
|
if (m_position != position) {
|
|
|
m_position = position;
|
|
|
emit positionChanged();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Gets the position of the pie within its bounding rectangle.
|
|
|
\sa PiePosition, setPosition()
|
|
|
*/
|
|
|
QPieSeries::PiePosition QPieSeries::position() const
|
|
|
{
|
|
|
return m_position;
|
|
|
}
|
|
|
|
|
|
|
|
|
/*!
|
|
|
Sets the \a startAngle and \a angleSpan of this series.
|
|
|
|
|
|
Full pie is 360 degrees where 0 degrees is at 12 a'clock.
|
|
|
*/
|
|
|
void QPieSeries::setSpan(qreal startAngle, qreal angleSpan)
|
|
|
{
|
|
|
if (startAngle >= 0 && startAngle < 360 &&
|
|
|
angleSpan > 0 && angleSpan <= 360) {
|
|
|
m_pieStartAngle = startAngle;
|
|
|
m_pieAngleSpan = angleSpan;
|
|
|
updateDerivativeData();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Sets the all the slice labels \a visible or invisible.
|
|
|
|
|
|
\sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
|
|
|
*/
|
|
|
void QPieSeries::setLabelsVisible(bool visible)
|
|
|
{
|
|
|
foreach (QPieSlice* s, m_slices)
|
|
|
s->setLabelVisible(visible);
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Convenience method for exploding a slice when user clicks the pie. Set \a enable to true to
|
|
|
explode slices by clicking.
|
|
|
|
|
|
\sa QPieSlice::isExploded(), QPieSlice::setExploded(), QPieSlice::setExplodeDistance()
|
|
|
*/
|
|
|
void QPieSeries::enableClickExplodes(bool enable)
|
|
|
{
|
|
|
if (enable)
|
|
|
connect(this, SIGNAL(clicked(QPieSlice*)), this, SLOT(toggleExploded(QPieSlice*)));
|
|
|
else
|
|
|
disconnect(this, SLOT(toggleExploded(QPieSlice*)));
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Convenience method for highlighting a slice when user hovers over the slice.
|
|
|
It changes the slice color to be lighter and shows the label of the slice.
|
|
|
Set \a enable to true to highlight a slice when user hovers on top of it.
|
|
|
|
|
|
\sa QPieSlice::isExploded(), QPieSlice::setExploded()
|
|
|
*/
|
|
|
|
|
|
void QPieSeries::enableHoverHighlight(bool enable)
|
|
|
{
|
|
|
if (enable) {
|
|
|
connect(this, SIGNAL(hoverEnter(QPieSlice*)), this, SLOT(highlightOn(QPieSlice*)));
|
|
|
connect(this, SIGNAL(hoverLeave(QPieSlice*)), this, SLOT(highlightOff(QPieSlice*)));
|
|
|
} else {
|
|
|
disconnect(this, SLOT(hoverEnter(QPieSlice*)));
|
|
|
disconnect(this, SLOT(hoverLeave(QPieSlice*)));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
\fn void QPieSeries::changed(const QPieSeries::ChangeSet& changeSet)
|
|
|
|
|
|
This signal emitted when something has changed in the series.
|
|
|
The \a changeSet contains the details of which slices have been added, changed or removed.
|
|
|
|
|
|
\sa QPieSeries::ChangeSet, QPieSlice::changed()
|
|
|
*/
|
|
|
|
|
|
/*!
|
|
|
\fn void QPieSeries::clicked(QPieSlice* slice)
|
|
|
|
|
|
This signal is emitted when a \a slice has been clicked.
|
|
|
|
|
|
\sa QPieSlice::clicked()
|
|
|
*/
|
|
|
|
|
|
/*!
|
|
|
\fn void QPieSeries::hoverEnter(QPieSlice* slice)
|
|
|
|
|
|
This signal is emitted when user has hovered over a \a slice.
|
|
|
|
|
|
\sa QPieSlice::hoverEnter()
|
|
|
*/
|
|
|
|
|
|
/*!
|
|
|
\fn void QPieSeries::hoverLeave(QPieSlice* slice)
|
|
|
|
|
|
This signal is emitted when user has hovered away from a \a slice.
|
|
|
|
|
|
\sa QPieSlice::hoverLeave()
|
|
|
*/
|
|
|
|
|
|
/*!
|
|
|
\fn void QPieSeries::sizeFactorChanged()
|
|
|
|
|
|
This signal is emitted when size factor has been changed.
|
|
|
|
|
|
\sa sizeFactor(), setSizeFactor()
|
|
|
*/
|
|
|
|
|
|
/*!
|
|
|
\fn void QPieSeries::positionChanged()
|
|
|
|
|
|
This signal is emitted when position of the pie has been changed.
|
|
|
|
|
|
\sa position(), setPosition()
|
|
|
*/
|
|
|
|
|
|
void QPieSeries::sliceChanged()
|
|
|
{
|
|
|
QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
|
|
|
Q_ASSERT(m_slices.contains(slice));
|
|
|
|
|
|
ChangeSet changeSet;
|
|
|
changeSet.appendChanged(slice);
|
|
|
emit changed(changeSet);
|
|
|
|
|
|
updateDerivativeData();
|
|
|
}
|
|
|
|
|
|
void QPieSeries::sliceClicked()
|
|
|
{
|
|
|
QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
|
|
|
Q_ASSERT(m_slices.contains(slice));
|
|
|
emit clicked(slice);
|
|
|
}
|
|
|
|
|
|
void QPieSeries::sliceHoverEnter()
|
|
|
{
|
|
|
QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
|
|
|
Q_ASSERT(m_slices.contains(slice));
|
|
|
emit hoverEnter(slice);
|
|
|
}
|
|
|
|
|
|
void QPieSeries::sliceHoverLeave()
|
|
|
{
|
|
|
QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
|
|
|
Q_ASSERT(m_slices.contains(slice));
|
|
|
emit hoverLeave(slice);
|
|
|
}
|
|
|
|
|
|
void QPieSeries::toggleExploded(QPieSlice* slice)
|
|
|
{
|
|
|
Q_ASSERT(slice);
|
|
|
slice->setExploded(!slice->isExploded());
|
|
|
}
|
|
|
|
|
|
void QPieSeries::highlightOn(QPieSlice* slice)
|
|
|
{
|
|
|
Q_ASSERT(slice);
|
|
|
QColor c = slice->brush().color().lighter();
|
|
|
slice->setBrush(c);
|
|
|
slice->setLabelVisible(true);
|
|
|
}
|
|
|
|
|
|
void QPieSeries::highlightOff(QPieSlice* slice)
|
|
|
{
|
|
|
Q_ASSERT(slice);
|
|
|
QColor c = slice->brush().color().darker(150);
|
|
|
slice->setBrush(c);
|
|
|
slice->setLabelVisible(false);
|
|
|
}
|
|
|
|
|
|
void QPieSeries::updateDerivativeData()
|
|
|
{
|
|
|
m_total = 0;
|
|
|
|
|
|
// nothing to do?
|
|
|
if (m_slices.count() == 0)
|
|
|
return;
|
|
|
|
|
|
// calculate total
|
|
|
foreach (QPieSlice* s, m_slices)
|
|
|
m_total += s->value();
|
|
|
|
|
|
// we must have some values
|
|
|
Q_ASSERT(m_total > 0); // TODO: is this the correct way to handle this?
|
|
|
|
|
|
// update slice attributes
|
|
|
qreal sliceAngle = m_pieStartAngle;
|
|
|
foreach (QPieSlice* s, m_slices) {
|
|
|
|
|
|
bool changed = false;
|
|
|
|
|
|
qreal percentage = s->value() / m_total;
|
|
|
if (s->m_percentage != percentage) {
|
|
|
s->m_percentage = percentage;
|
|
|
changed = true;
|
|
|
}
|
|
|
|
|
|
qreal sliceSpan = m_pieAngleSpan * percentage;
|
|
|
if (s->m_angleSpan != sliceSpan) {
|
|
|
s->m_angleSpan = sliceSpan;
|
|
|
changed = true;
|
|
|
}
|
|
|
|
|
|
if (s->m_angle != sliceAngle) {
|
|
|
s->m_angle = sliceAngle;
|
|
|
changed = true;
|
|
|
}
|
|
|
sliceAngle += sliceSpan;
|
|
|
|
|
|
if (changed)
|
|
|
emit s->changed();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#include "moc_qpieseries.cpp"
|
|
|
|
|
|
QTCOMMERCIALCHART_END_NAMESPACE
|
|
|
|
