HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r209:c977a59b6d90

Fix issue with pie label not drawn correctly when first created

Jani Honkonen -

r209:c977a59b6d90

parent child

Context file:

r209:c977a59b6d90

Collapse all files

src/piechart/piepresenter.cpp +2 0

             #include "piepresenter.h"
             #include "pieslice.h"
             #include "qpieslice.h"
             #include <QDebug>
             #include <QTime>
             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()));
             }
             PiePresenter::~PiePresenter()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PiePresenter::paint(QPainter *, 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
                 // changeset might not be valid about the added slices
                 if (m_slices.count() == 0) {
                     foreach (QPieSlice* s, m_series->m_slices)
                         addSlice(s);
                     return;
                 }
                 foreach (QPieSlice* s, changeSet.removed())
                     deleteSlice(s);
                 foreach (QPieSlice* s, changeSet.added())
                     addSlice(s);
             }
             void PiePresenter::handleDomainChanged(const Domain& domain)
             {
                 // TODO
             }
             void PiePresenter::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
                 updateGeometry();
             }
             void PiePresenter::updateGeometry()
             {
                 prepareGeometryChange();
                 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());
                 }
                 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;
                 }
                 if (m_pieRect != pieRect) {
                     m_pieRect = pieRect;
                     //qDebug() << "PiePresenter::updateGeometry()" << m_pieRect;
                     foreach (PieSlice* s, m_slices.values()) {
                         s->setPieRect(m_pieRect);
                         s->updateGeometry();
                     }
                 }
             }
             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);
                     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::deleteSlice(QPieSlice* sliceData)
             {
                 //qDebug() << "PiePresenter::deleteSlice()" << sliceData;
                 if (m_slices.contains(sliceData))
                     delete m_slices.take(sliceData);
                 else {
                     // nothing to remove
                     Q_ASSERT(0); // TODO: remove before release
                 }
             }
             #include "moc_piepresenter.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslice.cpp +3 -5

             #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_isExploded(false)
             {
                 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->setRenderHint(QPainter::Antialiasing);
                 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()
             {
                 prepareGeometryChange();
                 // calculate center angle
                 qreal centerAngle = m_angle + (m_span/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);
                     rect.translate(d.x(), d.y());
                 }
                 // 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.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();
                 //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_isExploded = sliceData->isExploded();
                 m_pen = sliceData->pen();
                 m_brush = sliceData->brush();
-                updateGeometry();
-                update();
                 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->updateGeometry(); // text size & font modifies the geometry
+                updateGeometry();
+                update();
                 m_slicelabel->update();
             }
             #include "moc_pieslice.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslicelabel.cpp +9 -3

             #include "pieslicelabel.h"
             #include <QPainter>
             #include <qmath.h>
             #include <QGraphicsTextItem>
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             #define PI 3.14159265
             PieSliceLabel::PieSliceLabel(QGraphicsItem* parent)
-                :QGraphicsItem(parent)
+                :QGraphicsItem(parent),
+                m_armAngle(0),
+                m_armLength(0)
             {
-                // set defaults
-                m_pen = QPen(Qt::black);
             }
             void PieSliceLabel::paint(QPainter *painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->setRenderHint(QPainter::Antialiasing);
                 painter->setPen(m_pen);
                 painter->drawPath(m_armPath);
                 // TODO: do we need a pen for text?
                 painter->setFont(m_font);
                 painter->drawText(m_textRect, m_text);
+                //qDebug() << "PieSliceLabel::paint" << m_text << m_textRect;
             }
             void PieSliceLabel::updateGeometry()
             {
                 prepareGeometryChange();
                 // calculate text size
                 QFontMetricsF fm(m_font);
                 QRectF textRect = fm.boundingRect(m_text);
                 // calculate path for arm and text start point
                 qreal dx = qSin(m_armAngle*(PI/180)) * m_armLength;
                 qreal dy = -qCos(m_armAngle*(PI/180)) * m_armLength;
                 QPointF parm1 = m_armStartPoint + QPointF(dx, dy);
                 // calculate horizontal arm and text position
                 QPointF parm2 = parm1;
                 textRect.moveBottomLeft(parm1);
                 if (m_armAngle < 180) { // arm swings the other way on the left side
                      parm2 += QPointF(m_textRect.width(), 0);
                 } else {
                      parm2 += QPointF(-m_textRect.width(),0);
                      textRect.moveBottomLeft(parm2);
                 }
                 // update arm path
                 QPainterPath path;
                 path.moveTo(m_armStartPoint);
                 path.lineTo(parm1);
                 path.lineTo(parm2);
                 // update paths & rects
                 m_armPath = path;
                 m_textRect = textRect;
                 m_rect = path.boundingRect().united(m_textRect);
+                //qDebug() << "PieSliceLabel::updateGeometry" << m_text << m_armStartPoint << m_armLength << m_armAngle << m_textRect;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

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