HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r289:46889b1144e0

Make pie fit better inside its given rectangle. Label texts still go outside. Needs a bit more work...

Jani Honkonen -

r289:46889b1144e0

parent child

Context file:

r289:46889b1144e0

Collapse all files

example/piechart/main.cpp 0 -3

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
             #include "customslice.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 QPieSeries *series = new QPieSeries();
                 series->add(5, "Slice 1");
                 series->add(2, "Slice 2");
                 series->add(3, "Slice 3");
                 series->add(4, "Slice 4");
                 series->add(5, "Slice 5");
                 series->add(6, "Slice 6");
                 series->add(7, "Slice 7");
                 series->add(new CustomSlice(8));
                 series->enableClickExplodes(true);
                 series->enableHoverHighlight(true);
-                foreach (QPieSlice*s, series->slices())
-                    qDebug() << s->angle() << s->span() << s->percentage();
                 QChartView* chartView =  new QChartView(&window);
                 chartView->setRenderHint(QPainter::Antialiasing);
                 chartView->addSeries(series);
                 chartView->setChartTitle("simple piechart");
                 chartView->setChartTheme(QChart::ChartThemeIcy);
                 window.setCentralWidget(chartView);
                 window.resize(600, 600);
                 window.show();
                 return a.exec();
             }

src/piechart/piepresenter.cpp +74 -22

             #include "piepresenter.h"
             #include "pieslice.h"
             #include "qpieslice.h"
+            #include "pieslicelabel.h"
+            #include "qpieseries.h"
+            #include <qmath.h>
             #include <QDebug>
-            #include <QTime>
+            #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 *, const QStyleOptionGraphicsItem *, QWidget *)
+            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();
-                // ignore changeset when there are no visual slices
+                foreach (QPieSlice* s, changeSet.added())
-                // changeset might not be valid about the added slices
+                    addSlice(s);
-                if (m_slices.count() == 0) {
-                    foreach (QPieSlice* s, m_series->m_slices)
+                foreach (QPieSlice* s, changeSet.changed())
-                        addSlice(s);
+                    updateSlice(s);
-                    return;
                 foreach (QPieSlice* s, changeSet.removed())
                     deleteSlice(s);
-                foreach (QPieSlice* s, changeSet.added())
+                // every change possibly changes the actual pie size
-                    addSlice(s);
+                updateGeometry();
             }
             void PiePresenter::handleDomainChanged(const Domain& domain)
             {
                 // TODO
             }
             void PiePresenter::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
+                prepareGeometryChange();
                 updateGeometry();
             }
             void PiePresenter::updateGeometry()
             {
-                prepareGeometryChange();
+                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 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_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)) {
-                    //qWarning() << "PiePresenter::addSlice(): slice already exists!" << sliceData;
+                    Q_ASSERT(0); // TODO: how to handle this nicely?
-                    Q_ASSERT(0);
                     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(sliceData, SIGNAL(changed()), slice, SLOT(handleSliceDataChanged()));
                 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))
+                if (!m_slices.contains(sliceData)) {
-                    delete m_slices.take(sliceData);
+                    Q_ASSERT(0); // TODO: how to handle this nicely?
-                else {
+                    return;
-                    // nothing to remove
-                    Q_ASSERT(0); // TODO: remove before release
                 }
+                delete m_slices.take(sliceData);
             }
             #include "moc_piepresenter.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piepresenter.h +3 0

             #ifndef PIEPRESENTER_H
             #define PIEPRESENTER_H
             #include "chartitem_p.h"
             #include "qpieseries.h"
             #include <QSignalMapper>
             class QGraphicsItem;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieSlice;
+            #define PI 3.14159265 // TODO: is this defined in some header?
             class PiePresenter : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 // TODO: use a generic data class instead of x and y
                 PiePresenter(QGraphicsItem *parent, QPieSeries *series);
                 ~PiePresenter();
             public: // from QGraphicsItem
                 QRectF boundingRect() const { return m_rect; }
                 void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *);
             public:
                 QRectF pieRect() const { return m_pieRect; }
             public Q_SLOTS:
                 void handleSeriesChanged(const QPieSeries::ChangeSet& changeSet);
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& rect);
                 void updateGeometry();
             private:
                 void addSlice(QPieSlice* sliceData);
+                void updateSlice(QPieSlice* sliceData);
                 void deleteSlice(QPieSlice* sliceData);
             private:
                 friend class PieSlice;
                 QHash<QPieSlice*, PieSlice*> m_slices;
                 QPieSeries *m_series;
                 QRectF m_rect;
                 QRectF m_pieRect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIEPRESENTER_H

src/piechart/pieslice.cpp +15 -20

             #include "pieslice.h"
             #include "pieslicelabel.h"
             #include "piepresenter.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include <QPainter>
             #include <QDebug>
             #include <qmath.h>
             #include <QGraphicsSceneEvent>
             #include <QTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            #define PI 3.14159265
-            #define EXPLODE_OFFSET 20
             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_span(0),
+                m_angleSpan(0),
-                m_isExploded(false)
+                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_span/2);
+                qreal centerAngle = m_angle + (m_angleSpan/2);
                 // adjust rect for exploding
                 QRectF rect = m_pieRect;
-                rect.adjust(EXPLODE_OFFSET, EXPLODE_OFFSET, -EXPLODE_OFFSET ,-EXPLODE_OFFSET);
                 if (m_isExploded) {
-                    QPointF d = offset((centerAngle), EXPLODE_OFFSET);
+                    qreal dx = qSin(centerAngle*(PI/180)) * m_explodeDistance;
-                    rect.translate(d.x(), d.y());
+                    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_span);
+                path.arcTo(rect, -m_angle + 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::handleSliceDataChanged()
-                QPieSlice *slice = qobject_cast<QPieSlice*>(sender());
-                Q_ASSERT(slice);
-                updateData(slice);
             void PieSlice::updateData(const QPieSlice* sliceData)
             {
                 // TODO: compare what has changes to avoid unneccesary geometry updates
                 m_angle = sliceData->angle();
-                m_span = sliceData->span();
+                m_angleSpan = sliceData->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->labelArmLenght());
+                m_slicelabel->setArmLength(sliceData->labelArmLength());
                 updateGeometry();
                 update();
-                m_slicelabel->update();
             }
             #include "moc_pieslice.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslice.h +6 -2

             #ifndef PIESLICE_H
             #define PIESLICE_H
             #include "qchartglobal.h"
             #include "charttheme_p.h"
             #include "qpieseries.h"
             #include <QGraphicsItem>
             #include <QRectF>
             #include <QColor>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PiePresenter;
             class 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 handleSliceDataChanged();
                 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_span;
+                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 +11 -4

             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "piepresenter.h"
             #include "pieslice.h"
+            #include <QFontMetrics>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             void QPieSeries::ChangeSet::appendAdded(QPieSlice* slice)
             {
                 if (!m_added.contains(slice))
                     m_added << slice;
             }
+            void QPieSeries::ChangeSet::appendAdded(QList<QPieSlice*> slices)
+            {
+                foreach (QPieSlice* s, slices)
+                    appendAdded(s);
+            }
             void QPieSeries::ChangeSet::appendChanged(QPieSlice* slice)
             {
                 if (!m_changed.contains(slice))
                     m_changed << slice;
             }
             void QPieSeries::ChangeSet::appendRemoved(QPieSlice* slice)
             {
                 if (!m_removed.contains(slice))
                     m_removed << slice;
             }
             QList<QPieSlice*> QPieSeries::ChangeSet::added() const
             {
                 return m_added;
             }
             QList<QPieSlice*> QPieSeries::ChangeSet::changed() const
             {
                 return m_changed;
             }
             QList<QPieSlice*> QPieSeries::ChangeSet::removed() const
             {
                 return m_removed;
             }
             bool QPieSeries::ChangeSet::isEmpty() const
             {
                 if (m_added.count() || m_changed.count() || m_removed.count())
                     return false;
                 return true;
             }
             QPieSeries::QPieSeries(QObject *parent) :
                 QChartSeries(parent),
                 m_sizeFactor(1.0),
                 m_position(PiePositionMaximized),
                 m_pieStartAngle(0),
                 m_pieSpan(360)
             {
             }
             QPieSeries::~QPieSeries()
             {
             }
             bool QPieSeries::setData(QList<qreal> data)
             {
                 // TODO: remove this function
                 QList<QPieSlice*> slices;
                 foreach (qreal value, data)
                     slices << new QPieSlice(value, QString::number(value));
                 set(slices);
                 return true;
             }
             void QPieSeries::set(QList<QPieSlice*> slices)
             {
                 clear();
                 add(slices);
             }
             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);
             }
             void QPieSeries::add(QPieSlice* slice)
             {
                 add(QList<QPieSlice*>() << slice);
             }
             QPieSlice* QPieSeries::add(qreal value, QString name)
             {
                 QPieSlice* slice = new QPieSlice(value, name);
                 add(slice);
                 return slice;
             }
             void QPieSeries::remove(QPieSlice* slice)
             {
                 if (!m_slices.removeOne(slice)) {
-                    Q_ASSERT(0); // TODO: remove before release
+                    Q_ASSERT(0); // TODO: how should this be reported?
                     return;
                 }
                 ChangeSet changeSet;
                 changeSet.appendRemoved(slice);
                 emit changed(changeSet);
                 delete slice;
                 slice = NULL;
                 updateDerivativeData();
             }
             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();
             }
             void QPieSeries::setSizeFactor(qreal factor)
             {
                 if (factor < 0.0)
                     return;
                 if (m_sizeFactor != factor) {
                     m_sizeFactor = factor;
                     emit sizeFactorChanged();
                 }
             }
             void QPieSeries::setPosition(PiePosition position)
             {
                 if (m_position != position) {
                     m_position = position;
                     emit positionChanged();
                 }
             }
             void QPieSeries::setSpan(qreal startAngle, qreal span)
             {
                 if (startAngle >= 0 && startAngle < 360 &&
                     span > 0 && span <= 360) {
                     m_pieStartAngle = startAngle;
                     m_pieSpan = span;
                     updateDerivativeData();
                 }
             }
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 foreach (QPieSlice* s, m_slices)
                     s->setLabelVisible(visible);
             }
             void QPieSeries::enableClickExplodes(bool enable)
             {
                 if (enable)
                     connect(this, SIGNAL(clicked(QPieSlice*)), this, SLOT(toggleExploded(QPieSlice*)));
                 else
                     disconnect(this, SLOT(toggleExploded(QPieSlice*)));
             }
             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*)));
                 }
             }
             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);
             }
             void QPieSeries::highlightOff(QPieSlice* slice)
             {
                 Q_ASSERT(slice);
                 QColor c = slice->brush().color().darker(150);
                 slice->setBrush(c);
             }
             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
+                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_pieSpan * percentage;
-                    if (s->m_span != sliceSpan) {
+                    if (s->m_angleSpan != sliceSpan) {
-                        s->m_span = 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

src/piechart/qpieseries.h +13 -9

             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include "qchartseries.h"
             #include <QObject>
             #include <QRectF>
             #include <QColor>
             #include <QPen>
             #include <QBrush>
             #include <QSignalMapper>
             class QGraphicsObject;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PiePresenter;
             class PieSlice;
             class QPieSlice;
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
                 enum PiePosition {
                     PiePositionMaximized = 0,
                     PiePositionTopLeft,
                     PiePositionTopRight,
                     PiePositionBottomLeft,
                     PiePositionBottomRight
                 };
                 class ChangeSet
                 {
                 public:
                     void appendAdded(QPieSlice* slice);
+                    void appendAdded(QList<QPieSlice*> slices);
                     void appendChanged(QPieSlice* slice);
                     void appendRemoved(QPieSlice* slice);
                     QList<QPieSlice*> added() const;
                     QList<QPieSlice*> changed() const;
                     QList<QPieSlice*> removed() const;
                     bool isEmpty() const;
                 private:
                     QList<QPieSlice*> m_added;
                     QList<QPieSlice*> m_changed;
                     QList<QPieSlice*> m_removed;
                 };
             public:
                 QPieSeries(QObject *parent = 0);
                 virtual ~QPieSeries();
             public: // from QChartSeries
                 QChartSeriesType type() const { return QChartSeries::SeriesTypePie; }
                 virtual bool setData(QList<qreal> data);  // TODO: remove this
             public:
                 void set(QList<QPieSlice*> slices);
                 void add(QList<QPieSlice*> slices);
                 void add(QPieSlice* slice);
                 QPieSlice* add(qreal value, QString name);
                 void remove(QPieSlice* slice);
                 void clear();
                 int count() const { return m_slices.count(); }
                 QList<QPieSlice*> slices() const { return m_slices; }
-                // TODO: find slices?
-                // QList<QPieSlice*> findByValue(qreal value);
-                // ...
-                // TODO: sorting slices?
-                // void sort(QPieSeries::SortByValue)
                 void setSizeFactor(qreal sizeFactor);
                 qreal sizeFactor() const { return m_sizeFactor; }
                 void setPosition(PiePosition position);
                 PiePosition position() const { return m_position; }
                 void setSpan(qreal startAngle, qreal span);
                 void setLabelsVisible(bool visible);
                 void enableClickExplodes(bool enable);
                 void enableHoverHighlight(bool enable);
+                // TODO: find slices?
+                // QList<QPieSlice*> findByValue(qreal value);
+                // ...
+                // TODO: sorting slices?
+                // void sort(QPieSeries::SortByValue|label|??)
+                // TODO: general graphics customization
+                // setDrawStyle(2d|3d)
+                // setDropShadows(bool)
             Q_SIGNALS:
                 void changed(const QPieSeries::ChangeSet& changeSet);
                 void clicked(QPieSlice* slice);
                 void hoverEnter(QPieSlice* slice);
                 void hoverLeave(QPieSlice* slice);
                 void sizeFactorChanged();
                 void positionChanged();
-            private Q_SLOTS: // should be private and not in the interface
+            private Q_SLOTS: // TODO: should be private and not visible in the interface at all
                 void sliceChanged();
                 void sliceClicked();
                 void sliceHoverEnter();
                 void sliceHoverLeave();
                 void toggleExploded(QPieSlice* slice);
                 void highlightOn(QPieSlice* slice);
                 void highlightOff(QPieSlice* slice);
             private:
                 void updateDerivativeData();
             private:
                 Q_DISABLE_COPY(QPieSeries)
                 // TODO: use PIML
                 friend class PiePresenter;
                 friend class PieSlice;
                 QList<QPieSlice*> m_slices;
                 qreal m_sizeFactor;
                 PiePosition m_position;
                 qreal m_total;
                 qreal m_pieStartAngle;
                 qreal m_pieSpan;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/piechart/qpieslice.cpp +24 -8

             #include "qpieslice.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            #define DEFAULT_PEN_COLOR        Qt::black
+            #define DEFAULT_PEN_COLOR         Qt::black
-            #define DEFAULT_BRUSH_COLOR      Qt::white
+            #define DEFAULT_BRUSH_COLOR       Qt::white
-            #define DEFAULT_LABEL_ARM_LENGTH 50
+            #define DEFAULT_LABEL_ARM_LENGTH  50
+            #define DEFAULT_EXPOLODE_DISTANCE 20
             QPieSlice::QPieSlice(QObject *parent)
                 :QObject(parent),
                 m_value(0),
                 m_isLabelVisible(true),
                 m_isExploded(false),
+                m_explodeDistance(DEFAULT_EXPOLODE_DISTANCE),
                 m_percentage(0),
                 m_angle(0),
-                m_span(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)
             {
             }
             QPieSlice::QPieSlice(qreal value, QString label, bool labelVisible, QObject *parent)
                 :QObject(parent),
                 m_value(value),
                 m_label(label),
                 m_isLabelVisible(labelVisible),
                 m_isExploded(false),
+                m_explodeDistance(DEFAULT_EXPOLODE_DISTANCE),
                 m_percentage(0),
                 m_angle(0),
-                m_span(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)
             {
             }
             QPieSlice::~QPieSlice()
             {
             }
             qreal QPieSlice::value() const
             {
                 return m_value;
             }
             QString QPieSlice::label() const
             {
                 return m_label;
             }
             bool QPieSlice::isLabelVisible() const
             {
                 return m_isLabelVisible;
             }
             bool QPieSlice::isExploded() const
             {
                 return m_isExploded;
             }
+            qreal QPieSlice::explodeDistance() const
+            {
+                return m_explodeDistance;
+            }
             qreal QPieSlice::percentage() const
             {
                 return m_percentage;
             }
             qreal QPieSlice::angle() const
             {
                 return m_angle;
             }
-            qreal QPieSlice::span() const
+            qreal QPieSlice::angleSpan() const
             {
-                return m_span;
+                return m_angleSpan;
             }
             QPen QPieSlice::pen() const
             {
                 return m_pen;
             }
             QBrush QPieSlice::brush() const
             {
                 return m_brush;
             }
             QPen QPieSlice::labelPen() const
             {
                 return m_labelPen;
             }
             QFont QPieSlice::labelFont() const
             {
                 return m_labelFont;
             }
-            qreal QPieSlice::labelArmLenght() const
+            qreal QPieSlice::labelArmLength() const
             {
                 return m_labelArmLength;
             }
             void QPieSlice::setValue(qreal value)
             {
                 if (m_value != value) {
                     m_value = value;
                     emit changed();
                 }
             }
             void QPieSlice::setLabel(QString label)
             {
                 if (m_label != label) {
                     m_label = label;
                     emit changed();
                 }
             }
             void QPieSlice::setLabelVisible(bool visible)
             {
                 if (m_isLabelVisible != visible) {
                     m_isLabelVisible = visible;
                     emit changed();
                 }
             }
             void QPieSlice::setExploded(bool exploded)
             {
                 if (m_isExploded != exploded) {
                     m_isExploded = exploded;
                     emit changed();
                 }
             }
+            void QPieSlice::setExplodeDistance(qreal distance)
+            {
+                if (m_explodeDistance != distance) {
+                    m_explodeDistance = distance;
+                    emit changed();
+                }
+            }
             void QPieSlice::setPen(QPen pen)
             {
                 if (m_pen != pen) {
                     m_pen = pen;
                     emit changed();
                 }
             }
             void QPieSlice::setBrush(QBrush brush)
             {
                 if (m_brush != brush) {
                     m_brush = brush;
                     emit changed();
                 }
             }
             void QPieSlice::setLabelFont(QFont font)
             {
                 if (m_labelFont != font) {
                     m_labelFont = font;
                     emit changed();
                 }
             }
             void QPieSlice::setLabelPen(QPen pen)
             {
                 if (m_labelPen != pen) {
                     m_labelPen = pen;
                     emit changed();
                 }
             }
             void QPieSlice::setLabelArmLength(qreal len)
             {
                 if (m_labelArmLength != len) {
                     m_labelArmLength = len;
                     emit changed();
                 }
             }
             #include "moc_qpieslice.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieslice.h +11 -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 dataYChanged*/)
                 Q_PROPERTY(qreal value READ value WRITE setValue /*NOTIFY dataXChanged*/)
             public:
                 QPieSlice(QObject *parent = 0);
                 QPieSlice(qreal value, QString label, bool labelVisible = true, 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 span() const;
+                qreal angleSpan() const;
                 // customization
                 QPen pen() const;
                 QBrush brush() const;
                 QPen labelPen() const;
                 QFont labelFont() const;
-                qreal labelArmLenght() 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;
                 // 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_span;
+                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