HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r413:afa09ce7f031

Pie now actually withs the given rectangle and does not go over

Jani Honkonen -

r413:afa09ce7f031

parent child

Context file:

r413:afa09ce7f031

Collapse all files

src/piechart/piepresenter.cpp +12 -2

             #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
+                    // the arm
                     qreal centerAngle = s->m_startAngle + (s->m_angleSpan / 2);
-                    qreal len = pieRadius + s->labelArmLength() + s->explodeDistance();
+                    qreal len = pieRadius + PIESLICE_LABEL_GAP + 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
+                    // the label text
+                    QFontMetricsF fm(s->labelFont());
+                    QRectF labelRect = fm.boundingRect(s->label());
+                    if (centerAngle < 90 || centerAngle > 270)
+                        p += QPointF(0, -labelRect.height());
+                    if (centerAngle < 180)
+                        p += QPointF(labelRect.width(), 0);
+                    else
+                        p += QPointF(-labelRect.width(), 0);
                     // 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 +1 -1

             #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_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_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_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);
+                QPointF edgeCenter = rect.center() + offset(centerAngle, radius + PIESLICE_LABEL_GAP);
                 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_startAngle = sliceData->startAngle();
                 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 +2 0

             #ifndef PIESLICE_H
             #define PIESLICE_H
             #include "qchartglobal.h"
             #include "charttheme_p.h"
             #include "qpieseries.h"
             #include <QGraphicsItem>
             #include <QRectF>
             #include <QColor>
             #include <QPen>
+            #define PIESLICE_LABEL_GAP 5
             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_startAngle;
                 qreal m_angleSpan;
                 bool m_isExploded;
                 qreal m_explodeDistance;
                 QPen m_pen;
                 QBrush m_brush;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICE_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