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

                 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);

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
                 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?
                 //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)
             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());
                 }
+                // position the pie rectangle
                 switch (m_series->position()) {
                     case QPieSeries::PiePositionTopLeft: {
                         pieRect.setHeight(pieRect.height() / 2);
                         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();
                     }
                 }
             }
                 //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;
                 }
                 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"

src/piechart/piepresenter.h +3 0

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieSlice;
+            #define PI 3.14159265 // TODO: is this defined in some header?
             class PiePresenter : public QObject, public ChartItem
             {
                 Q_OBJECT
             private:
                 void addSlice(QPieSlice* sliceData);
+                void updateSlice(QPieSlice* sliceData);
                 void deleteSlice(QPieSlice* sliceData);
             private:

src/piechart/pieslice.cpp +15 -20

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            #define PI 3.14159265
-            #define EXPLODE_OFFSET 20
             QPointF offset(qreal angle, qreal length)
             {
                 qreal dx = qSin(angle*(PI/180)) * length;
                 :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);
             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;
                 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->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"

src/piechart/pieslice.h +6 -2

                 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;
                 QPainterPath m_path;
                 qreal m_angle;
-                qreal m_span;
+                qreal m_angleSpan;
                 bool m_isExploded;
+                qreal m_explodeDistance;
                 QPen m_pen;
                 QBrush m_brush;

src/piechart/qpieseries.cpp +11 -4

             #include "qpieslice.h"
             #include "piepresenter.h"
             #include "pieslice.h"
+            #include <QFontMetrics>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
                     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))
             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;
                 }
                     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;
                     }
                     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;
                     }

src/piechart/qpieseries.h +13 -9

                 {
                 public:
                     void appendAdded(QPieSlice* slice);
+                    void appendAdded(QList<QPieSlice*> slices);
                     void appendChanged(QPieSlice* slice);
                     void appendRemoved(QPieSlice* slice);
                 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 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 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);

src/piechart/qpieslice.cpp +24 -8

             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_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),
                 return m_isExploded;
             }
+            qreal QPieSlice::explodeDistance() const
+            {
+                return m_explodeDistance;
+            }
             qreal QPieSlice::percentage() const
             {
                 return m_percentage;
                 return m_angle;
             }
-            qreal QPieSlice::span() const
+            qreal QPieSlice::angleSpan() const
             {
-                return m_span;
+                return m_angleSpan;
             }
             QPen QPieSlice::pen() const
                 return m_labelFont;
             }
-            qreal QPieSlice::labelArmLenght() const
+            qreal QPieSlice::labelArmLength() const
             {
                 return m_labelArmLength;
             }
                 }
             }
+            void QPieSlice::setExplodeDistance(qreal distance)
+            {
+                if (m_explodeDistance != distance) {
+                    m_explodeDistance = distance;
+                    emit changed();
+                }
+            }
             void QPieSlice::setPen(QPen pen)
             {
                 if (m_pen != pen) {

src/piechart/qpieslice.h +11 -3

                 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 setLabelVisible(bool visible);
                 void setValue(qreal value);
                 void setExploded(bool exploded);
+                void setExplodeDistance(qreal distance);
                 // customization
                 void setPen(QPen pen);
                 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;

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