HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r294:bf1f84426ed8

Hide slice label by default

Jani Honkonen -

r294:bf1f84426ed8

parent child

Context file:

r294:bf1f84426ed8

Collapse all files

example/piechart/customslice.cpp +3 -1

             #include "customslice.h"
             CustomSlice::CustomSlice(qreal value, QObject* parent)
                 :QPieSlice(parent)
             {
                 setValue(value);
+                setLabelVisible(true);
+                setExploded(true);
                 connect(this, SIGNAL(changed()), this, SLOT(updateLabel()));
                 connect(this, SIGNAL(hoverEnter()), this, SLOT(toggleExploded()));
                 connect(this, SIGNAL(hoverLeave()), this, SLOT(toggleExploded()));
             }
             void CustomSlice::updateLabel()
             {
-                setLabel(QString::number(this->percentage()));
+                setLabel(QString::number(this->percentage()*100) + "%");
             }
             void CustomSlice::toggleExploded()
             {
                 setExploded(!isExploded());
             }

src/piechart/qpieseries.cpp +2 0

             #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: 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);
+                slice->setLabelVisible(true);
             }
             void QPieSeries::highlightOff(QPieSlice* slice)
             {
                 Q_ASSERT(slice);
                 QColor c = slice->brush().color().darker(150);
                 slice->setBrush(c);
+                slice->setLabelVisible(false);
             }
             void QPieSeries::updateDerivativeData()
             {
                 m_total = 0;
                 // nothing to do?
                 if (m_slices.count() == 0)
                     return;
                 // calculate total
                 foreach (QPieSlice* s, m_slices)
                     m_total += s->value();
                 // we must have some values
                 Q_ASSERT(m_total > 0); // TODO: is this the correct way to handle this?
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 foreach (QPieSlice* s, m_slices) {
                     bool changed = false;
                     qreal percentage = s->value() / m_total;
                     if (s->m_percentage != percentage) {
                         s->m_percentage = percentage;
                         changed = true;
                     }
                     qreal sliceSpan = m_pieSpan * percentage;
                     if (s->m_angleSpan != 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/qpieslice.cpp +1 -1

             #include "qpieslice.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             #define DEFAULT_PEN_COLOR         Qt::black
             #define DEFAULT_BRUSH_COLOR       Qt::white
             #define DEFAULT_LABEL_ARM_LENGTH  50
             #define DEFAULT_EXPOLODE_DISTANCE 20
             QPieSlice::QPieSlice(QObject *parent)
                 :QObject(parent),
                 m_value(0),
-                m_isLabelVisible(true),
+                m_isLabelVisible(false),
                 m_isExploded(false),
                 m_explodeDistance(DEFAULT_EXPOLODE_DISTANCE),
                 m_percentage(0),
                 m_angle(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_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::angleSpan() const
             {
                 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::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 +1 -1

             #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);
+                QPieSlice(qreal value, QString label, bool labelVisible = false, 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 angleSpan() const;
                 // customization
                 QPen pen() const;
                 QBrush brush() const;
                 QPen labelPen() const;
                 QFont labelFont() const;
                 qreal labelArmLength() const;
             Q_SIGNALS:
                 void clicked();
                 void hoverEnter();
                 void hoverLeave();
                 void changed();
             public Q_SLOTS:
                 // data
                 void setLabel(QString label);
                 void setLabelVisible(bool visible);
                 void setValue(qreal value);
                 void setExploded(bool exploded);
                 void setExplodeDistance(qreal distance);
                 // customization
                 void setPen(QPen pen);
                 void setBrush(QBrush brush);
                 void setLabelFont(QFont font);
                 void setLabelPen(QPen pen);
                 void setLabelArmLength(qreal len);
                 // TODO: label position in general
                 // setLabelFlags(inside|outside|labelArmOn|labelArmOff|???)
                 // setLabelOrientation(horizontal|vertical|same as slice center angle|???)
             private:
                 // TODO: use private class
                 friend class QPieSeries;
                 friend class PiePresenter;
                 // 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_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