HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r355:b889b21eeadf

QPieSlice: angle() -> startAngle(), angleSpan() -> endAngle()

Jani Honkonen -

r355:b889b21eeadf

parent child

Context file:

r355:b889b21eeadf

Collapse all files

src/piechart/piepresenter.cpp +1 -1

             #include "piepresenter_p.h"
             #include "pieslice_p.h"
             #include "qpieslice.h"
             #include "pieslicelabel_p.h"
             #include "qpieseries.h"
             #include <qmath.h>
             #include <QDebug>
             #include <QFontMetrics>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PiePresenter::PiePresenter(QGraphicsItem *parent, QPieSeries *series)
                 :ChartItem(parent),
                 m_series(series)
             {
                 Q_ASSERT(series);
                 connect(series, SIGNAL(changed(const QPieSeries::ChangeSet&)), this, SLOT(handleSeriesChanged(const QPieSeries::ChangeSet&)));
                 connect(series, SIGNAL(sizeFactorChanged()), this, SLOT(updateGeometry()));
                 connect(series, SIGNAL(positionChanged()), this, SLOT(updateGeometry()));
                 if (m_series->count()) {
                     QPieSeries::ChangeSet changeSet;
                     changeSet.appendAdded(m_series->m_slices);
                     handleSeriesChanged(changeSet);
                 }
             }
             PiePresenter::~PiePresenter()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PiePresenter::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
             {
                 // TODO: paint shadows for all components
                 // - get paths from items & merge & offset and draw with shadow color?
             }
             void PiePresenter::handleSeriesChanged(const QPieSeries::ChangeSet& changeSet)
             {
                 //qDebug() << "PiePresenter::handleSeriesChanged()";
                 //qDebug() << "  added  : " << changeSet.added();
                 //qDebug() << "  changed: " << changeSet.changed();
                 //qDebug() << "  removed: " << changeSet.removed();
                 foreach (QPieSlice* s, changeSet.added())
                     addSlice(s);
                 foreach (QPieSlice* s, changeSet.changed())
                     updateSlice(s);
                 foreach (QPieSlice* s, changeSet.removed())
                     deleteSlice(s);
                 // every change possibly changes the actual pie size
                 updateGeometry();
             }
             void PiePresenter::handleDomainChanged(const Domain& domain)
             {
                 // TODO
             }
             void PiePresenter::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
                 prepareGeometryChange();
                 updateGeometry();
             }
             void PiePresenter::updateGeometry()
             {
                 if (!m_rect.isValid() || m_rect.isEmpty())
                     return;
                 // calculate maximum rectangle for pie
                 QRectF pieRect = m_rect;
                 if (pieRect.width() < pieRect.height()) {
                     pieRect.setWidth(pieRect.width() * m_series->sizeFactor());
                     pieRect.setHeight(pieRect.width());
                     pieRect.moveCenter(m_rect.center());
                 } else {
                     pieRect.setHeight(pieRect.height() * m_series->sizeFactor());
                     pieRect.setWidth(pieRect.height());
                     pieRect.moveCenter(m_rect.center());
                 }
                 // position the pie rectangle
                 switch (m_series->position()) {
                     case QPieSeries::PiePositionTopLeft: {
                         pieRect.setHeight(pieRect.height() / 2);
                         pieRect.setWidth(pieRect.height());
                         pieRect.moveCenter(QPointF(m_rect.center().x() / 2, m_rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionTopRight: {
                         pieRect.setHeight(pieRect.height() / 2);
                         pieRect.setWidth(pieRect.height());
                         pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, m_rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionBottomLeft: {
                         pieRect.setHeight(pieRect.height() / 2);
                         pieRect.setWidth(pieRect.height());
                         pieRect.moveCenter(QPointF(m_rect.center().x() / 2, (m_rect.center().y() / 2) * 3));
                         break;
                     }
                     case QPieSeries::PiePositionBottomRight: {
                         pieRect.setHeight(pieRect.height() / 2);
                         pieRect.setWidth(pieRect.height());
                         pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, (m_rect.center().y() / 2) * 3));
                         break;
                     }
                     default:
                         break;
                 }
                 // calculate how much space we need around the pie rectangle (labels & exploding)
                 qreal delta = 0;
                 qreal pieRadius = pieRect.height() / 2;
                 foreach (QPieSlice* s, m_series->m_slices) {
                     // calculate the farthest point in the slice from the pie center
-                    qreal centerAngle = s->angle() + (s->angleSpan() / 2);
+                    qreal centerAngle = s->m_startAngle + (s->m_angleSpan / 2);
                     qreal len = pieRadius + s->labelArmLength() + s->explodeDistance();
                     QPointF dp(qSin(centerAngle*(PI/180)) * len, -qCos(centerAngle*(PI/180)) * len);
                     QPointF p = pieRect.center() + dp;
                     // TODO: consider the label text
                     // calculate how much the radius must get smaller to fit that point in the base rectangle
                     qreal dt = m_rect.top() - p.y();
                     if (dt > delta) delta = dt;
                     qreal dl = m_rect.left() - p.x();
                     if (dl > delta) delta = dl;
                     qreal dr = p.x() - m_rect.right();
                     if (dr > delta) delta = dr;
                     qreal db = p.y() - m_rect.bottom();
                     if (db > delta) delta = db;
                     //if (!m_rect.contains(p)) qDebug() << s->label() << dt << dl << dr << db << "delta" << delta;
                 }
                 // shrink the pie rectangle so that everything outside it fits the base rectangle
                 pieRect.adjust(delta, delta, -delta, -delta);
                 // update slices
                 if (m_pieRect != pieRect) {
                     m_pieRect = pieRect;
                     //qDebug() << "PiePresenter::updateGeometry()" << m_rect << m_pieRect;
                     foreach (PieSlice* s, m_slices.values()) {
                         s->setPieRect(m_pieRect);
                         s->updateGeometry();
                         s->update();
                     }
                 }
             }
             void PiePresenter::addSlice(QPieSlice* sliceData)
             {
                 //qDebug() << "PiePresenter::addSlice()" << sliceData;
                 if (m_slices.keys().contains(sliceData)) {
                     Q_ASSERT(0); // TODO: how to handle this nicely?
                     return;
                 }
                 // create slice
                 PieSlice *slice = new PieSlice(this);
                 slice->setPieRect(m_pieRect);
                 slice->updateData(sliceData);
                 slice->updateGeometry();
                 slice->update();
                 m_slices.insert(sliceData, slice);
                 // connect signals
                 connect(slice, SIGNAL(clicked()), sliceData, SIGNAL(clicked()));
                 connect(slice, SIGNAL(hoverEnter()), sliceData, SIGNAL(hoverEnter()));
                 connect(slice, SIGNAL(hoverLeave()), sliceData, SIGNAL(hoverLeave()));
             }
             void PiePresenter::updateSlice(QPieSlice* sliceData)
             {
                 //qDebug() << "PiePresenter::updateSlice()" << sliceData;
                 if (!m_slices.contains(sliceData)) {
                     Q_ASSERT(0); // TODO: how to handle this nicely?
                     return;
                 }
                 m_slices[sliceData]->updateData(sliceData);
             }
             void PiePresenter::deleteSlice(QPieSlice* sliceData)
             {
                 //qDebug() << "PiePresenter::deleteSlice()" << sliceData;
                 if (!m_slices.contains(sliceData)) {
                     Q_ASSERT(0); // TODO: how to handle this nicely?
                     return;
                 }
                 delete m_slices.take(sliceData);
             }
             #include "moc_piepresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslice.cpp +5 -5

             #include "pieslice_p.h"
             #include "pieslicelabel_p.h"
             #include "piepresenter_p.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include <QPainter>
             #include <QDebug>
             #include <qmath.h>
             #include <QGraphicsSceneEvent>
             #include <QTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QPointF offset(qreal angle, qreal length)
             {
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = qCos(angle*(PI/180)) * length;
                 return QPointF(dx, -dy);
             }
             PieSlice::PieSlice(QGraphicsItem* parent)
                 :QGraphicsObject(parent),
                 m_slicelabel(new PieSliceLabel(this)),
-                m_angle(0),
+                m_startAngle(0),
                 m_angleSpan(0),
                 m_isExploded(false),
                 m_explodeDistance(0)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::LeftButton);
             }
             PieSlice::~PieSlice()
             {
             }
             QRectF PieSlice::boundingRect() const
             {
                 return m_path.boundingRect();
             }
             QPainterPath PieSlice::shape() const
             {
                 return m_path;
             }
             void PieSlice::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->setPen(m_pen);
                 painter->setBrush(m_brush);
                 painter->drawPath(m_path);
             }
             void PieSlice::hoverEnterEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverEnter();
             }
             void PieSlice::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverLeave();
             }
             void PieSlice::mousePressEvent(QGraphicsSceneMouseEvent* /*event*/)
             {
                 emit clicked();
             }
             void PieSlice::setPieRect(QRectF rect)
             {
                 m_pieRect = rect;
             }
             void PieSlice::updateGeometry()
             {
                 if (!m_pieRect.isValid() || m_pieRect.isEmpty())
                     return;
                 prepareGeometryChange();
                 // calculate center angle
-                qreal centerAngle = m_angle + (m_angleSpan/2);
+                qreal centerAngle = m_startAngle + (m_angleSpan/2);
                 // adjust rect for exploding
                 QRectF rect = m_pieRect;
                 if (m_isExploded) {
                     qreal dx = qSin(centerAngle*(PI/180)) * m_explodeDistance;
                     qreal dy = -qCos(centerAngle*(PI/180)) * m_explodeDistance;
                     rect.translate(dx, dy);
                 }
                 // update 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, -m_angle + 90, -m_angleSpan);
+                path.arcTo(rect, -m_startAngle + 90, -m_angleSpan);
                 path.closeSubpath();
                 m_path = path;
                 // update label position
                 qreal radius = rect.height() / 2;
                 QPointF edgeCenter = rect.center() + offset(centerAngle, radius + 5);
                 m_slicelabel->setArmStartPoint(edgeCenter);
                 m_slicelabel->setArmAngle(centerAngle);
                 m_slicelabel->updateGeometry();
                 m_slicelabel->update();
                 //qDebug() << "PieSlice::updateGeometry" << m_slicelabel->text() << boundingRect() << m_angle << m_span;
             }
             void PieSlice::updateData(const QPieSlice* sliceData)
             {
                 // TODO: compare what has changes to avoid unneccesary geometry updates
-                m_angle = sliceData->angle();
+                m_startAngle = sliceData->startAngle();
-                m_angleSpan = sliceData->angleSpan();
+                m_angleSpan = sliceData->m_angleSpan;
                 m_isExploded = sliceData->isExploded();
                 m_explodeDistance = sliceData->explodeDistance(); // TODO: expose to public API
                 m_pen = sliceData->pen();
                 m_brush = sliceData->brush();
                 m_slicelabel->setVisible(sliceData->isLabelVisible());
                 m_slicelabel->setText(sliceData->label());
                 m_slicelabel->setPen(sliceData->labelPen());
                 m_slicelabel->setFont(sliceData->labelFont());
                 m_slicelabel->setArmLength(sliceData->labelArmLength());
                 updateGeometry();
                 update();
             }
             #include "moc_pieslice_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslice_p.h +1 -1

             #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 PieSliceLabel;
             class QPieSlice;
             class PieSlice : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 PieSlice(QGraphicsItem* parent = 0);
                 ~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);
             Q_SIGNALS:
                 void clicked();
                 void hoverEnter();
                 void hoverLeave();
             public Q_SLOTS:
                 void setPieRect(QRectF rect);
                 void updateGeometry();
                 void updateData(const QPieSlice *sliceData);
             public:
                 PieSliceLabel* label() { return m_slicelabel; }
             private:
                 PieSliceLabel* m_slicelabel;
                 QRectF m_pieRect;
                 QPainterPath m_path;
-                qreal m_angle;
+                qreal m_startAngle;
                 qreal m_angleSpan;
                 bool m_isExploded;
                 qreal m_explodeDistance;
                 QPen m_pen;
                 QBrush m_brush;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICE_H

src/piechart/qpieseries.cpp +2 -2

             #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) {
+                    if (s->m_startAngle != sliceAngle) {
-                        s->m_angle = sliceAngle;
+                        s->m_startAngle = sliceAngle;
                         changed = true;
                     }
                     sliceAngle += sliceSpan;
                     if (changed)
                         emit s->changed();
                 }
             }
             #include "moc_qpieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieslice.cpp +7 -7

             #include "qpieslice.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             #define DEFAULT_PEN_COLOR         Qt::black
             #define DEFAULT_BRUSH_COLOR       Qt::white
             #define DEFAULT_LABEL_ARM_LENGTH  40
             #define DEFAULT_EXPOLODE_DISTANCE 20
             /*!
                 \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::set(), QPieSeries::add()
             */
             QPieSlice::QPieSlice(QObject *parent)
                 :QObject(parent),
                 m_value(0),
                 m_isLabelVisible(false),
                 m_isExploded(false),
                 m_explodeDistance(DEFAULT_EXPOLODE_DISTANCE),
                 m_percentage(0),
-                m_angle(0),
+                m_startAngle(0),
                 m_angleSpan(0),
                 m_pen(DEFAULT_PEN_COLOR),
                 m_brush(DEFAULT_BRUSH_COLOR),
                 m_labelPen(DEFAULT_PEN_COLOR),
                 m_labelArmLength(DEFAULT_LABEL_ARM_LENGTH)
             {
             }
             /*!
                 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::set(), QPieSeries::add()
             */
             QPieSlice::QPieSlice(qreal value, QString label, QObject *parent)
                 :QObject(parent),
                 m_value(value),
                 m_label(label),
                 m_isLabelVisible(false),
                 m_isExploded(false),
                 m_explodeDistance(DEFAULT_EXPOLODE_DISTANCE),
                 m_percentage(0),
-                m_angle(0),
+                m_startAngle(0),
                 m_angleSpan(0),
                 m_pen(DEFAULT_PEN_COLOR),
                 m_brush(DEFAULT_BRUSH_COLOR),
                 m_labelPen(DEFAULT_PEN_COLOR),
                 m_labelArmLength(DEFAULT_LABEL_ARM_LENGTH)
             {
             }
             /*!
                 Destroys the slice.
                 User should not delete the slice if it has been added to the series.
             */
             QPieSlice::~QPieSlice()
             {
             }
             /*!
                 Gets the value of the slice.
                 Note that all values in the series
                 \sa setValue()
             */
             qreal QPieSlice::value() const
             {
                 return m_value;
             }
             /*!
                 Gets the label of the slice.
                 \sa setLabel()
             */
             QString QPieSlice::label() const
             {
                 return m_label;
             }
             /*!
                 Returns true if label is set as visible.
                 \sa setLabelVisible()
             */
             bool QPieSlice::isLabelVisible() const
             {
                 return m_isLabelVisible;
             }
             /*!
                 Returns true if slice is exloded from the pie.
                 \sa setExploded()
             */
             bool QPieSlice::isExploded() const
             {
                 return m_isExploded;
             }
             /*!
                 Returns the explosion distance of the slice.
                 Default value is 20.
                 \sa setExplodeDistance()
             */
             qreal QPieSlice::explodeDistance() const
             {
                 return m_explodeDistance;
             }
             /*!
                 Returns the percentage of this slice compared to all slices in the same series.
                 Updated internally after the slice is added to the series.
             */
             qreal QPieSlice::percentage() const
             {
                 return 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::angle() const
+            qreal QPieSlice::startAngle() const
             {
-                return m_angle;
+                return m_startAngle;
             }
             /*!
-                Returns the angle span of this slice in the series it belongs to.
+                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::angleSpan() const
+            qreal QPieSlice::endAngle() const
             {
-                return m_angleSpan;
+                return m_startAngle + m_angleSpan;
             }
             /*!
                 Returns the pen used to draw this slice.
                 \sa setPen()
             */
             QPen QPieSlice::pen() const
             {
                 return m_pen;
             }
             /*!
                 Returns the brush used to draw this slice.
                 \sa setBrush()
             */
             QBrush QPieSlice::brush() const
             {
                 return m_brush;
             }
             /*!
                 Returns the pen used to draw label in this slice.
                 \sa setLabelPen()
             */
             QPen QPieSlice::labelPen() const
             {
                 return m_labelPen;
             }
             /*!
                 Returns the font used to draw label in this slice.
                 \sa setLabelFont()
             */
             QFont QPieSlice::labelFont() const
             {
                 return m_labelFont;
             }
             /*!
                 Returns the label arm lenght used in this slice.
                 Default value is 40 pixels.
                 \sa setLabelArmLength()
             */
             qreal QPieSlice::labelArmLength() const
             {
                 return m_labelArmLength;
             }
             /*!
                 \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 value of this slice.
                 \sa value()
             */
             void QPieSlice::setValue(qreal value)
             {
                 if (m_value != value) {
                     m_value = value;
                     emit changed();
                 }
             }
             /*!
                 Sets the \a label of the slice.
                 \sa label()
             */
             void QPieSlice::setLabel(QString label)
             {
                 if (m_label != label) {
                     m_label = label;
                     emit changed();
                 }
             }
             /*!
                 Sets the label \a visible in this slice.
                 \sa isLabelVisible(), QPieSeries::setLabelsVisible()
             */
             void QPieSlice::setLabelVisible(bool visible)
             {
                 if (m_isLabelVisible != visible) {
                     m_isLabelVisible = visible;
                     emit changed();
                 }
             }
             /*!
                 Sets this slice \a exploded.
                 \sa isExploded(), setExplodeDistance(), QPieSeries::enableClickExplodes()
             */
             void QPieSlice::setExploded(bool exploded)
             {
                 if (m_isExploded != exploded) {
                     m_isExploded = exploded;
                     emit changed();
                 }
             }
             /*!
                 Sets the explosion \a distance of this slice.
                 It is the distance the slice is moved away from the pie center.
                 \sa explodeDistance(), isExploded(), QPieSeries::enableClickExplodes()
             */
             void QPieSlice::setExplodeDistance(qreal distance)
             {
                 if (m_explodeDistance != distance) {
                     m_explodeDistance = distance;
                     emit changed();
                 }
             }
             /*!
                 Sets the \a pen used to draw this slice.
                 Note that applying a theme will override this.
                 \sa pen()
             */
             void QPieSlice::setPen(QPen pen)
             {
                 if (m_pen != pen) {
                     m_pen = pen;
                     emit changed();
                 }
             }
             /*!
                 Sets the \a brush used to draw this slice.
                 Note that applying a theme will override this.
                 \sa brush()
             */
             void QPieSlice::setBrush(QBrush brush)
             {
                 if (m_brush != brush) {
                     m_brush = brush;
                     emit changed();
                 }
             }
             /*!
                 Sets the \a pen used to draw the label in this slice.
                 Note that applying a theme will override this.
                 \sa labelPen()
             */
             void QPieSlice::setLabelPen(QPen pen)
             {
                 if (m_labelPen != pen) {
                     m_labelPen = pen;
                     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(QFont font)
             {
                 if (m_labelFont != font) {
                     m_labelFont = font;
                     emit changed();
                 }
             }
             /*!
                 Sets the label arm \a length used to draw the label in this slice.
                 \sa labelArmLength()
             */
             void QPieSlice::setLabelArmLength(qreal length)
             {
                 if (m_labelArmLength != length) {
                     m_labelArmLength = length;
                     emit changed();
                 }
             }
             #include "moc_qpieslice.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieslice.h +4 -3

             #ifndef QPIESLICE_H
             #define QPIESLICE_H
             #include <qchartglobal.h>
             #include <QObject>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QPieSlice : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString label READ label WRITE setLabel NOTIFY changed)
                 Q_PROPERTY(qreal value READ value WRITE setValue NOTIFY changed)
             public:
                 QPieSlice(QObject *parent = 0);
                 QPieSlice(qreal value, QString label, QObject *parent = 0);
                 virtual ~QPieSlice();
                 // data
                 qreal value() const;
                 QString label() const;
                 bool isLabelVisible() const;
                 bool isExploded() const;
                 qreal explodeDistance() const;
                 // generated data
                 qreal percentage() const;
-                qreal angle() const;
+                qreal startAngle() const;
-                qreal angleSpan() const;
+                qreal endAngle() const;
                 // customization
                 QPen pen() const;
                 QBrush brush() const;
                 QPen labelPen() const;
                 QFont labelFont() const;
                 qreal labelArmLength() const;
             Q_SIGNALS:
                 void clicked();
                 void hoverEnter();
                 void hoverLeave();
                 void changed();
             public Q_SLOTS:
                 // data
                 void setLabel(QString label);
                 void setLabelVisible(bool visible);
                 void setValue(qreal value);
                 void setExploded(bool exploded);
                 void setExplodeDistance(qreal distance);
                 // customization
                 void setPen(QPen pen);
                 void setBrush(QBrush brush);
                 void setLabelFont(QFont font);
                 void setLabelPen(QPen pen);
                 void setLabelArmLength(qreal len);
                 // TODO: label position in general
                 // setLabelFlags(inside|outside|labelArmOn|labelArmOff|???)
                 // setLabelOrientation(horizontal|vertical|same as slice center angle|???)
             private:
                 // TODO: use private class
                 friend class QPieSeries;
                 friend class PiePresenter;
+                friend class PieSlice;
                 // data
                 qreal m_value;
                 QString m_label;
                 bool m_isLabelVisible;
                 bool m_isExploded;
                 qreal m_explodeDistance;
                 // generated data
                 qreal m_percentage;
-                qreal m_angle;
+                qreal m_startAngle;
                 qreal m_angleSpan;
                 // customization
                 QPen m_pen;
                 QBrush m_brush;
                 QPen m_labelPen;
                 QFont m_labelFont;
                 qreal m_labelArmLength;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESLICE_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