HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1482:57681a863659

Removed a few signals from QPieSeries API

Tero Ahola -

r1482:57681a863659

parent child

Context file:

r1482:57681a863659

Collapse all files

src/piechart/piechartitem.cpp +5 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "piechartitem_p.h"
             #include "piesliceitem_p.h"
             #include "qpieslice.h"
             #include "qpieslice_p.h"
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter* presenter)
                 :ChartItem(presenter),
                 m_series(series)
             {
                 Q_ASSERT(series);
+                QPieSeriesPrivate *p = QPieSeriesPrivate::fromSeries(series);
                 connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 connect(series, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
                 connect(series, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
-                connect(series, SIGNAL(horizontalPositionChanged()), this, SLOT(updateLayout()));
+                connect(p, SIGNAL(horizontalPositionChanged()), this, SLOT(updateLayout()));
-                connect(series, SIGNAL(verticalPositionChanged()), this, SLOT(updateLayout()));
+                connect(p, SIGNAL(verticalPositionChanged()), this, SLOT(updateLayout()));
-                connect(series, SIGNAL(pieSizeChanged()), this, SLOT(updateLayout()));
+                connect(p, SIGNAL(pieSizeChanged()), this, SLOT(updateLayout()));
-                connect(QPieSeriesPrivate::fromSeries(series), SIGNAL(calculatedDataChanged()), this, SLOT(updateLayout()));
+                connect(p, SIGNAL(calculatedDataChanged()), this, SLOT(updateLayout()));
                 // Note: the following does not affect as long as the item does not have anything to paint
                 setZValue(ChartPresenter::PieSeriesZValue);
                 // Note: will not create slice items until we have a proper rectangle to draw on.
             }
             PieChartItem::~PieChartItem()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PieChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 updateLayout();
                 // This is for delayed initialization of the slice items during startup.
                 // It ensures that startup animation originates from the correct position.
                 if (m_sliceItems.isEmpty())
                     handleSlicesAdded(m_series->slices());
             }
             void PieChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 Q_UNUSED(minX);
                 Q_UNUSED(maxX);
                 Q_UNUSED(minY);
                 Q_UNUSED(maxY);
                 // does not apply to pie
             }
             void PieChartItem::rangeXChanged(qreal min, qreal max, int tickXCount)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 Q_UNUSED(tickXCount);
                 // does not apply to pie
             }
             void PieChartItem::rangeYChanged(qreal min, qreal max, int tickYCount)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 Q_UNUSED(tickYCount);
                 // does not apply to pie
             }
             void PieChartItem::updateLayout()
             {
                 // find pie center coordinates
                 m_pieCenter.setX(m_rect.left() + (m_rect.width() * m_series->horizontalPosition()));
                 m_pieCenter.setY(m_rect.top() + (m_rect.height() * m_series->verticalPosition()));
                 // find maximum radius for pie
                 m_pieRadius = m_rect.height() / 2;
                 if (m_rect.width() < m_rect.height())
                     m_pieRadius = m_rect.width() / 2;
                 // apply size factor
                 m_pieRadius *= m_series->pieSize();
                 // set layouts for existing slice items
                 foreach (QPieSlice* slice, m_series->slices()) {
                     PieSliceItem *sliceItem = m_sliceItems.value(slice);
                     if (sliceItem) {
                         PieSliceData sliceData = updateSliceGeometry(slice);
                         if (animator())
                             animator()->updateAnimation(this, sliceItem, sliceData);
                         else
                             sliceItem->setLayout(sliceData);
                     }
                 }
                 update();
             }
             void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
             {
                 // delay creating slice items until there is a proper rectangle
                 if (!m_rect.isValid() && m_sliceItems.isEmpty())
                     return;
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 bool startupAnimation = m_sliceItems.isEmpty();
                 foreach (QPieSlice *slice, slices) {
                     PieSliceItem* sliceItem = new PieSliceItem(this);
                     m_sliceItems.insert(slice, sliceItem);
                     // Note: do need to connect to slice valueChanged() etc.
                     // This is handled through calculatedDataChanged signal.
                     connect(slice, SIGNAL(labelChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelVisibleChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(explodedChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(penChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(brushChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelBrushChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelFontChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelPositionChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelArmLengthFactorChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(explodeDistanceFactorChanged()), this, SLOT(handleSliceChanged()));
                     connect(sliceItem, SIGNAL(clicked(Qt::MouseButtons)), slice, SIGNAL(clicked()));
                     connect(sliceItem, SIGNAL(hovered(bool)), slice, SIGNAL(hovered(bool)));
                     PieSliceData sliceData = updateSliceGeometry(slice);
                     if (animator())
                         animator()->addAnimation(this, sliceItem, sliceData, startupAnimation);
                     else
                         sliceItem->setLayout(sliceData);
                 }
             }
             void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices)
             {
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 foreach (QPieSlice *slice, slices) {
                     PieSliceItem *sliceItem = m_sliceItems.value(slice);
                     // this can happen if you call append() & remove() in a row so that PieSliceItem is not even created
                     if (!sliceItem)
                         continue;
                     m_sliceItems.remove(slice);
                     if (animator())
                         animator()->removeAnimation(this, sliceItem); // animator deletes the PieSliceItem
                     else
                         delete sliceItem;
                 }
             }
             void PieChartItem::handleSliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_sliceItems.contains(slice));
                 PieSliceItem *sliceItem = m_sliceItems.value(slice);
                 PieSliceData sliceData = updateSliceGeometry(slice);
                 if (animator())
                     animator()->updateAnimation(this, sliceItem, sliceData);
                 else
                     sliceItem->setLayout(sliceData);
                 update();
             }
             void PieChartItem::handleSeriesVisibleChanged()
             {
                 setVisible(m_series->isVisible());
             }
             PieSliceData PieChartItem::updateSliceGeometry(QPieSlice *slice)
             {
                 PieSliceData &sliceData = QPieSlicePrivate::fromSlice(slice)->m_data;
                 sliceData.m_center = PieSliceItem::sliceCenter(m_pieCenter, m_pieRadius, slice);
                 sliceData.m_radius = m_pieRadius;
                 return sliceData;
             }
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.cpp +5 -45

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "qpieslice_p.h"
             #include "pieslicedata_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "legendmarker_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are defined as QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 Pie size and position on the chart is controlled by using relative values which range from 0.0 to 1.0
                 These relate to the actual chart rectangle.
                 By default the pie is defined as a full pie but it can also be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 Full pie is 360 degrees where 0 is at 12 a'clock.
                 See the \l {PieChart Example} {pie chart example} to learn how to create a simple pie chart.
                 \image examples_piechart.png
             */
             /*!
                 \property QPieSeries::horizontalPosition
                 \brief Defines the horizontal position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute left.
                 \o 1.0 is the absolute right.
                 \endlist
                 Default value is 0.5 (center).
                 \sa verticalPosition
             */
             /*!
-                \fn void QPieSeries::horizontalPositionChanged()
-                Emitted then the horizontal position of the pie has changed.
-                \sa horizontalPosition
-            */
-            /*!
                 \property QPieSeries::verticalPosition
                 \brief Defines the vertical position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute top.
                 \o 1.0 is the absolute bottom.
                 \endlist
                 Default value is 0.5 (center).
                 \sa horizontalPosition
             */
             /*!
-                \fn void QPieSeries::verticalPositionChanged()
-                Emitted then the vertical position of the pie has changed.
-                \sa verticalPosition
-            */
-            /*!
                 \property QPieSeries::size
                 \brief Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (pie not drawn).
                 \o 1.0 is the maximum size that can fit the chart.
                 \endlist
                 Default value is 0.7.
             */
             /*!
-                \fn void QPieSeries::pieSizeChanged()
-                Emitted when the pie size has changed.
-                \sa size
-            */
-            /*!
                 \property QPieSeries::startAngle
                 \brief Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
-                \fn void QPieSeries::pieStartAngleChanged()
-                Emitted when the starting angle of the pie has changed.
-                \sa startAngle
-            */
-            /*!
                 \property QPieSeries::endAngle
                 \brief Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
-                \fn void QPieSeries::pieEndAngleChanged()
-                Emitted when the ending angle of the pie has changed.
-                \sa endAngle
-            */
-            /*!
                 \property QPieSeries::count
                 Number of slices in the series.
             */
             /*!
                 \fn void QPieSeries::countChanged()
                 Emitted when the slice count has changed.
                 \sa count
             */
             /*!
                 \property QPieSeries::sum
                 Sum of all slices.
                 The series keeps track of the sum of all slices it holds.
             */
             /*!
                 \fn void QPieSeries::sumChanged()
                 Emitted when the sum of all slices has changed.
                 \sa sum
             */
             /*!
                 \fn void QPieSeries::added(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \fn void QPieSeries::removed(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been removed from the series.
                 \sa remove()
             */
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
                 \fn void QPieSeries::hovered(QPieSlice* slice, bool state)
                 This signal is emitted when user has hovered over or away from the \a slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
                 \sa QPieSlice::hovered()
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
                 QAbstractSeries(*new QPieSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destroys the series and its slices.
             */
             QPieSeries::~QPieSeries()
             {
                 // NOTE: d_prt destroyed by QObject
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QAbstractSeries::SeriesType QPieSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePie;
             }
             /*!
                 Appends a single \a slice to the series.
                 Slice ownership is passed to the series.
                 Returns true if append was succesfull.
             */
             bool QPieSeries::append(QPieSlice* slice)
             {
                 return append(QList<QPieSlice*>() << slice);
             }
             /*!
                 Appends an array of \a slices to the series.
                 Slice ownership is passed to the series.
                 Returns true if append was successfull.
             */
             bool QPieSeries::append(QList<QPieSlice*> slices)
             {
                 Q_D(QPieSeries);
                 if (slices.count() == 0)
                     return false;
                 foreach (QPieSlice* s, slices) {
                     if (!s || d->m_slices.contains(s))
                         return false;
                     if (s->series()) // already added to some series
                         return false;
                 }
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     QPieSlicePrivate::fromSlice(s)->m_series = this;
                     d->m_slices << s;
                 }
                 d->updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                     connect(s, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 }
                 emit added(slices);
                 emit countChanged();
                 return true;
             }
             /*!
                 Appends a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries& QPieSeries::operator << (QPieSlice* slice)
             {
                 append(slice);
                 return *this;
             }
             /*!
                 Appends a single slice to the series with give \a value and \a label.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::append(QString label, qreal value)
             {
                 QPieSlice* slice = new QPieSlice(label, value);
                 append(slice);
                 return slice;
             }
             /*!
                 Inserts a single \a slice to the series before the slice at \a index position.
                 Slice ownership is passed to the series.
                 Returns true if insert was successfull.
             */
             bool QPieSeries::insert(int index, QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (index < 0 || index > d->m_slices.count())
                     return false;
                 if (!slice || d->m_slices.contains(slice))
                     return false;
                 if (slice->series()) // already added to some series
                     return false;
                 slice->setParent(this);
                 QPieSlicePrivate::fromSlice(slice)->m_series = this;
                 d->m_slices.insert(index, slice);
                 d->updateDerivativeData();
                 connect(slice, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                 connect(slice, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                 connect(slice, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 emit added(QList<QPieSlice*>() << slice);
                 emit countChanged();
                 return true;
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference the pointer after this call.
                 Returns true if remove was successfull.
             */
             bool QPieSeries::remove(QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice))
                     return false;
                 d->updateDerivativeData();
                 emit removed(QList<QPieSlice*>() << slice);
                 emit countChanged();
                 delete slice;
                 slice = 0;
                 return true;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 Q_D(QPieSeries);
                 if (d->m_slices.count() == 0)
                     return;
                 QList<QPieSlice*> slices = d->m_slices;
                 foreach (QPieSlice* s, d->m_slices) {
                     d->m_slices.removeOne(s);
                     delete s;
                 }
                 d->updateDerivativeData();
                 emit removed(slices);
                 emit countChanged();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices;
             }
             /*!
                 returns the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.count();
             }
             /*!
                 Returns true is the series is empty.
             */
             bool QPieSeries::isEmpty() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.isEmpty();
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue(), QPieSlice::percentage()
             */
             qreal QPieSeries::sum() const
             {
                 Q_D(const QPieSeries);
                 return d->m_sum;
             }
             void QPieSeries::setHorizontalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (relativePosition < 0.0)
                     relativePosition = 0.0;
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
                 if (!qFuzzyIsNull(d->m_pieRelativeHorPos - relativePosition)) {
                     d->m_pieRelativeHorPos = relativePosition;
-                    emit horizontalPositionChanged();
+                    emit d->horizontalPositionChanged();
                 }
             }
             qreal QPieSeries::horizontalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeHorPos;
             }
             void QPieSeries::setVerticalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (relativePosition < 0.0)
                     relativePosition = 0.0;
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
                 if (!qFuzzyIsNull(d->m_pieRelativeVerPos - relativePosition)) {
                     d->m_pieRelativeVerPos = relativePosition;
-                    emit verticalPositionChanged();
+                    emit d->verticalPositionChanged();
                 }
             }
             qreal QPieSeries::verticalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeVerPos;
             }
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 Q_D(QPieSeries);
                 if (relativeSize < 0.0)
                     relativeSize = 0.0;
                 if (relativeSize > 1.0)
                     relativeSize = 1.0;
                 if (!qFuzzyIsNull(d->m_pieRelativeSize - relativeSize)) {
                     d->m_pieRelativeSize = relativeSize;
-                    emit pieSizeChanged();
+                    emit d->pieSizeChanged();
                 }
             }
             qreal QPieSeries::pieSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeSize;
             }
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (qFuzzyIsNull(d->m_pieStartAngle - angle))
                     return;
                 d->m_pieStartAngle = angle;
                 d->updateDerivativeData();
-                emit pieStartAngleChanged();
+                emit d->pieStartAngleChanged();
             }
             qreal QPieSeries::pieStartAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieStartAngle;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be greater than start angle.
                 \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (qFuzzyIsNull(d->m_pieEndAngle - angle))
                     return;
                 d->m_pieEndAngle = angle;
                 d->updateDerivativeData();
-                emit pieEndAngleChanged();
+                emit d->pieEndAngleChanged();
             }
             /*!
                 Returns the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             qreal QPieSeries::pieEndAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 Note that this affects only the current slices in the series.
                 If user adds a new slice the default label visibility is false.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, d->m_slices)
                     s->setLabelVisible(visible);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent) :
                 QAbstractSeriesPrivate(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_sum(0)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
             }
             void QPieSeriesPrivate::updateDerivativeData()
             {
                 // calculate sum of all slices
                 qreal sum = 0;
                 foreach (QPieSlice* s, m_slices)
                     sum += s->value();
                 if (!qFuzzyIsNull(m_sum - sum)) {
                     m_sum = sum;
                     emit q_func()->sumChanged();
                 }
                 // nothing to show..
                 if (qFuzzyIsNull(m_sum))
                     return;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice*> changed;
                 foreach (QPieSlice* s, m_slices) {
                     QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
                     d->setPercentage(s->value() / m_sum);
                     d->setStartAngle(sliceAngle);
                     d->setAngleSpan(pieSpan * s->percentage());
                     sliceAngle += s->angleSpan();
                 }
                 emit calculatedDataChanged();
             }
             QPieSeriesPrivate* QPieSeriesPrivate::fromSeries(QPieSeries *series)
             {
                 return series->d_func();
             }
             void QPieSeriesPrivate::sliceValueChanged()
             {
                 Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
                 updateDerivativeData();
             }
             void QPieSeriesPrivate::sliceClicked()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->clicked(slice);
             }
             void QPieSeriesPrivate::sliceHovered(bool state)
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hovered(slice, state);
             }
             void QPieSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_UNUSED(domain);
                 // does not apply to pie
             }
             Chart* QPieSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QPieSeries);
                 PieChartItem* pie = new PieChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(pie);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return pie;
             }
             QList<LegendMarker*> QPieSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QPieSeries);
                 QList<LegendMarker*> markers;
                 foreach(QPieSlice* slice, q->slices()) {
                     PieLegendMarker* marker = new PieLegendMarker(q,slice,legend);
                     markers << marker;
                 }
                 return markers;
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.h +5 -10

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include <qabstractseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSeriesPrivate;
             class QPieSlice;
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QAbstractSeries
             {
                 Q_OBJECT
-                Q_PROPERTY(qreal horizontalPosition READ horizontalPosition WRITE setHorizontalPosition NOTIFY horizontalPositionChanged)
+                Q_PROPERTY(qreal horizontalPosition READ horizontalPosition WRITE setHorizontalPosition)
-                Q_PROPERTY(qreal verticalPosition READ verticalPosition WRITE setVerticalPosition NOTIFY verticalPositionChanged)
+                Q_PROPERTY(qreal verticalPosition READ verticalPosition WRITE setVerticalPosition)
-                Q_PROPERTY(qreal size READ pieSize WRITE setPieSize NOTIFY pieSizeChanged)
+                Q_PROPERTY(qreal size READ pieSize WRITE setPieSize)
-                Q_PROPERTY(qreal startAngle READ pieStartAngle WRITE setPieStartAngle NOTIFY pieStartAngleChanged)
+                Q_PROPERTY(qreal startAngle READ pieStartAngle WRITE setPieStartAngle)
-                Q_PROPERTY(qreal endAngle READ pieEndAngle WRITE setPieEndAngle NOTIFY pieEndAngleChanged)
+                Q_PROPERTY(qreal endAngle READ pieEndAngle WRITE setPieEndAngle)
                 Q_PROPERTY(int count READ count NOTIFY countChanged)
                 Q_PROPERTY(qreal sum READ sum NOTIFY sumChanged)
             public:
                 explicit QPieSeries(QObject *parent = 0);
                 virtual ~QPieSeries();
                 QAbstractSeries::SeriesType type() const;
                 bool append(QPieSlice* slice);
                 bool append(QList<QPieSlice*> slices);
                 QPieSeries& operator << (QPieSlice* slice);
                 QPieSlice* append(QString label, qreal value);
                 bool insert(int index, QPieSlice* slice);
                 bool remove(QPieSlice* slice);
                 void clear();
                 QList<QPieSlice*> slices() const;
                 int count() const;
                 bool isEmpty() const;
                 qreal sum() const;
                 void setHorizontalPosition(qreal relativePosition);
                 qreal horizontalPosition() const;
                 void setVerticalPosition(qreal relativePosition);
                 qreal verticalPosition() const;
                 void setPieSize(qreal relativeSize);
                 qreal pieSize() const;
                 void setPieStartAngle(qreal startAngle);
                 qreal pieStartAngle() const;
                 void setPieEndAngle(qreal endAngle);
                 qreal pieEndAngle() const;
                 void setLabelsVisible(bool visible = true);
             Q_SIGNALS:
                 void added(QList<QPieSlice*> slices);
                 void removed(QList<QPieSlice*> slices);
                 void clicked(QPieSlice* slice);
                 void hovered(QPieSlice* slice, bool state);
                 void countChanged();
                 void sumChanged();
-                void pieSizeChanged();
-                void pieStartAngleChanged();
-                void pieEndAngleChanged();
-                void horizontalPositionChanged();
-                void verticalPositionChanged();
             private:
                 Q_DECLARE_PRIVATE(QPieSeries)
                 Q_DISABLE_COPY(QPieSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/piechart/qpieseries_p.h +5 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QPIESERIES_P_H
             #define QPIESERIES_P_H
             #include "qpieseries.h"
             #include "qabstractseries_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLegendPrivate;
             class QPieSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QPieSeriesPrivate(QPieSeries *parent);
                 ~QPieSeriesPrivate();
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter *presenter);
                 QList<LegendMarker*> createLegendMarker(QLegend *legend);
                 void updateDerivativeData();
                 static QPieSeriesPrivate* fromSeries(QPieSeries *series);
             signals:
                 void calculatedDataChanged();
+                void pieSizeChanged();
+                void pieStartAngleChanged();
+                void pieEndAngleChanged();
+                void horizontalPositionChanged();
+                void verticalPositionChanged();
             public Q_SLOTS:
                 void sliceValueChanged();
                 void sliceClicked();
                 void sliceHovered(bool state);
             private:
                 QList<QPieSlice*> m_slices;
                 qreal m_pieRelativeHorPos;
                 qreal m_pieRelativeVerPos;
                 qreal m_pieRelativeSize;
                 qreal m_pieStartAngle;
                 qreal m_pieEndAngle;
                 qreal m_sum;
             private:
                 friend class QLegendPrivate;
                 Q_DECLARE_PUBLIC(QPieSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESERIES_P_H

tests/auto/qpieseries/tst_qpieseries.cpp +2 -10

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qchartview.h>
             #include <qchart.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
             #include <qpiemodelmapper.h>
             #include <QStandardItemModel>
             #include <tst_definitions.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QPieSlice*)
             Q_DECLARE_METATYPE(QList<QPieSlice*>)
             class tst_qpieseries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void properties();
                 void append();
                 void appendAnimated();
                 void insert();
                 void insertAnimated();
                 void remove();
                 void removeAnimated();
                 void calculatedValues();
                 void clickedSignal();
                 void hoverSignal();
                 void sliceSeries();
             private:
                 void verifyCalculatedData(const QPieSeries &series, bool *ok);
             private:
                 QChartView *m_view;
                 QPieSeries *m_series;
             };
             void tst_qpieseries::initTestCase()
             {
                 qRegisterMetaType<QPieSlice*>("QPieSlice*");
                 qRegisterMetaType<QList<QPieSlice*> >("QList<QPieSlice*>");
             }
             void tst_qpieseries::cleanupTestCase()
             {
             }
             void tst_qpieseries::init()
             {
                 m_view = new QChartView();
                 m_series = new QPieSeries(m_view);
             }
             void tst_qpieseries::cleanup()
             {
                 delete m_view;
                 m_view = 0;
                 m_series = 0;
             }
             void tst_qpieseries::properties()
             {
                 QSignalSpy countSpy(m_series, SIGNAL(countChanged()));
                 QSignalSpy sumSpy(m_series, SIGNAL(sumChanged()));
-                QSignalSpy sizeSpy(m_series, SIGNAL(pieSizeChanged()));
-                QSignalSpy startAngleSpy(m_series, SIGNAL(pieStartAngleChanged()));
-                QSignalSpy endAngleSpy(m_series, SIGNAL(pieEndAngleChanged()));
-                QSignalSpy horPosSpy(m_series, SIGNAL(horizontalPositionChanged()));
-                QSignalSpy verPosSpy(m_series, SIGNAL(verticalPositionChanged()));
                 QVERIFY(m_series->type() == QAbstractSeries::SeriesTypePie);
                 QVERIFY(m_series->count() == 0);
                 QVERIFY(m_series->isEmpty());
                 QCOMPARE(m_series->sum(), 0.0);
                 QCOMPARE(m_series->horizontalPosition(), 0.5);
                 QCOMPARE(m_series->verticalPosition(), 0.5);
                 QCOMPARE(m_series->pieSize(), 0.7);
                 QCOMPARE(m_series->pieStartAngle(), 0.0);
                 QCOMPARE(m_series->pieEndAngle(), 360.0);
                 m_series->append("s1", 1);
                 m_series->append("s2", 1);
                 m_series->append("s3", 1);
                 m_series->insert(1, new QPieSlice("s4", 1));
                 m_series->remove(m_series->slices().first());
                 QCOMPARE(m_series->count(), 3);
                 QCOMPARE(m_series->sum(), 3.0);
                 m_series->clear();
                 QCOMPARE(m_series->count(), 0);
                 QCOMPARE(m_series->sum(), 0.0);
                 QCOMPARE(countSpy.count(), 6);
                 QCOMPARE(sumSpy.count(), 6);
                 m_series->setPieSize(-1.0);
                 QCOMPARE(m_series->pieSize(), 0.0);
                 m_series->setPieSize(0.0);
                 m_series->setPieSize(0.9);
                 m_series->setPieSize(2.0);
                 QCOMPARE(m_series->pieSize(), 1.0);
-                QCOMPARE(sizeSpy.count(), 3);
                 m_series->setPieStartAngle(0);
                 m_series->setPieStartAngle(-180);
                 m_series->setPieStartAngle(180);
-                QCOMPARE(startAngleSpy.count(), 2);
+                QCOMPARE(m_series->pieStartAngle(), 180.0);
                 m_series->setPieEndAngle(360);
                 m_series->setPieEndAngle(-180);
                 m_series->setPieEndAngle(180);
-                QCOMPARE(endAngleSpy.count(), 2);
+                QCOMPARE(m_series->pieEndAngle(), 180.0);
                 m_series->setHorizontalPosition(0.5);
                 m_series->setHorizontalPosition(-1.0);
                 QCOMPARE(m_series->horizontalPosition(), 0.0);
                 m_series->setHorizontalPosition(1.0);
                 m_series->setHorizontalPosition(2.0);
                 QCOMPARE(m_series->horizontalPosition(), 1.0);
-                QCOMPARE(horPosSpy.count(), 2);
                 m_series->setVerticalPosition(0.5);
                 m_series->setVerticalPosition(-1.0);
                 QCOMPARE(m_series->verticalPosition(), 0.0);
                 m_series->setVerticalPosition(1.0);
                 m_series->setVerticalPosition(2.0);
                 QCOMPARE(m_series->verticalPosition(), 1.0);
-                QCOMPARE(verPosSpy.count(), 2);
             }
             void tst_qpieseries::append()
             {
                 m_view->chart()->addSeries(m_series);
                 QSignalSpy addedSpy(m_series, SIGNAL(added(QList<QPieSlice*>)));
                 // append pointer
                 QPieSlice *slice1 = 0;
                 QVERIFY(!m_series->append(slice1));
                 slice1 = new QPieSlice("slice 1", 1);
                 QVERIFY(m_series->append(slice1));
                 QVERIFY(!m_series->append(slice1));
                 QCOMPARE(m_series->count(), 1);
                 QCOMPARE(addedSpy.count(), 1);
                 QList<QPieSlice*> added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(0).at(0));
                 QCOMPARE(added.count(), 1);
                 QCOMPARE(added.first(), slice1);
                 // try to append same slice to another series
                 QPieSeries series2;
                 QVERIFY(!series2.append(slice1));
                 // append pointer list
                 QList<QPieSlice *> list;
                 QVERIFY(!m_series->append(list));
                 list << (QPieSlice *) 0;
                 QVERIFY(!m_series->append(list));
                 list.clear();
                 list << new QPieSlice("slice 2", 2);
                 list << new QPieSlice("slice 3", 3);
                 QVERIFY(m_series->append(list));
                 QVERIFY(!m_series->append(list));
                 QCOMPARE(m_series->count(), 3);
                 QCOMPARE(addedSpy.count(), 2);
                 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(1).at(0));
                 QCOMPARE(added.count(), 2);
                 QCOMPARE(added, list);
                 // append operator
                 QPieSlice *slice4 = new QPieSlice("slice 4", 4);
                 *m_series << slice4;
                 *m_series << slice1; // fails because already added
                 QCOMPARE(m_series->count(), 4);
                 QCOMPARE(addedSpy.count(), 3);
                 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(2).at(0));
                 QCOMPARE(added.count(), 1);
                 QCOMPARE(added.first(), slice4);
                 // append with params
                 QPieSlice *slice5 = m_series->append("slice 5", 5);
                 QVERIFY(slice5 != 0);
                 QCOMPARE(slice5->value(), 5.0);
                 QCOMPARE(slice5->label(), QString("slice 5"));
                 QCOMPARE(m_series->count(), 5);
                 QCOMPARE(addedSpy.count(), 4);
                 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(3).at(0));
                 QCOMPARE(added.count(), 1);
                 QCOMPARE(added.first(), slice5);
                 // check slices
                 QVERIFY(!m_series->isEmpty());
                 for (int i=0; i<m_series->count(); i++) {
                     QCOMPARE(m_series->slices().at(i)->value(), (qreal) i+1);
                     QCOMPARE(m_series->slices().at(i)->label(), QString("slice ") + QString::number(i+1));
                 }
             }
             void tst_qpieseries::appendAnimated()
             {
                 m_view->chart()->setAnimationOptions(QChart::AllAnimations);
             }
             void tst_qpieseries::insert()
             {
                 m_view->chart()->addSeries(m_series);
                 QSignalSpy addedSpy(m_series, SIGNAL(added(QList<QPieSlice*>)));
                 // insert one slice
                 QPieSlice *slice1 = 0;
                 QVERIFY(!m_series->insert(0, slice1));
                 slice1 = new QPieSlice("slice 1", 1);
                 QVERIFY(!m_series->insert(-1, slice1));
                 QVERIFY(!m_series->insert(5, slice1));
                 QVERIFY(m_series->insert(0, slice1));
                 QVERIFY(!m_series->insert(0, slice1));
                 QCOMPARE(m_series->count(), 1);
                 QCOMPARE(addedSpy.count(), 1);
                 QList<QPieSlice*> added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(0).at(0));
                 QCOMPARE(added.count(), 1);
                 QCOMPARE(added.first(), slice1);
                 // try to insert same slice to another series
                 QPieSeries series2;
                 QVERIFY(!series2.insert(0, slice1));
                 // add some more slices
                 QPieSlice *slice2 = m_series->append("slice 2", 2);
                 QPieSlice *slice4 = m_series->append("slice 4", 4);
                 QCOMPARE(m_series->count(), 3);
                 QCOMPARE(addedSpy.count(), 3);
                 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(1).at(0));
                 QCOMPARE(added.count(), 1);
                 QCOMPARE(added.first(), slice2);
                 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(2).at(0));
                 QCOMPARE(added.count(), 1);
                 QCOMPARE(added.first(), slice4);
                 // insert between slices
                 QPieSlice *slice3 = new QPieSlice("slice 3", 3);
                 m_series->insert(2, slice3);
                 QCOMPARE(m_series->count(), 4);
                 QCOMPARE(addedSpy.count(), 4);
                 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(3).at(0));
                 QCOMPARE(added.count(), 1);
                 QCOMPARE(added.first(), slice3);
                 // check slices
                 for (int i=0; i<m_series->count(); i++) {
                     QCOMPARE(m_series->slices().at(i)->value(), (qreal) i+1);
                     QCOMPARE(m_series->slices().at(i)->label(), QString("slice ") + QString::number(i+1));
                 }
             }
             void tst_qpieseries::insertAnimated()
             {
                 m_view->chart()->setAnimationOptions(QChart::AllAnimations);
             }
             void tst_qpieseries::remove()
             {
                 m_view->chart()->addSeries(m_series);
                 QSignalSpy removedSpy(m_series, SIGNAL(removed(QList<QPieSlice*>)));
                 // add some slices
                 QPieSlice *slice1 = m_series->append("slice 1", 1);
                 QPieSlice *slice2 = m_series->append("slice 2", 2);
                 QPieSlice *slice3 = m_series->append("slice 3", 3);
                 QSignalSpy spy1(slice1, SIGNAL(destroyed()));
                 QSignalSpy spy2(slice2, SIGNAL(destroyed()));
                 QSignalSpy spy3(slice3, SIGNAL(destroyed()));
                 QCOMPARE(m_series->count(), 3);
                 // null pointer remove
                 QVERIFY(!m_series->remove(0));
                 // remove first
                 QVERIFY(m_series->remove(slice1));
                 QVERIFY(!m_series->remove(slice1));
                 QCOMPARE(m_series->count(), 2);
                 QCOMPARE(m_series->slices().at(0)->label(), slice2->label());
                 QCOMPARE(removedSpy.count(), 1);
                 QList<QPieSlice*> removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(0).at(0));
                 QCOMPARE(removed.count(), 1);
                 QCOMPARE(removed.first(), slice1);
                 // remove all
                 m_series->clear();
                 QVERIFY(m_series->isEmpty());
                 QVERIFY(m_series->slices().isEmpty());
                 QCOMPARE(m_series->count(), 0);
                 QCOMPARE(removedSpy.count(), 2);
                 removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(1).at(0));
                 QCOMPARE(removed.count(), 2);
                 QCOMPARE(removed.first(), slice2);
                 QCOMPARE(removed.last(), slice3);
                 // check that slices were actually destroyed
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 1);
                 TRY_COMPARE(spy3.count(), 1);
             }
             void tst_qpieseries::removeAnimated()
             {
                 m_view->chart()->setAnimationOptions(QChart::AllAnimations);
             }
             void tst_qpieseries::calculatedValues()
             {
                 m_view->chart()->addSeries(m_series);
                 QPieSlice *slice1 = new QPieSlice("slice 1", 1);
                 QSignalSpy percentageSpy(slice1, SIGNAL(percentageChanged()));
                 QSignalSpy startAngleSpy(slice1, SIGNAL(startAngleChanged()));
                 QSignalSpy angleSpanSpy(slice1, SIGNAL(angleSpanChanged()));
                 // add a slice
                 m_series->append(slice1);
                 bool ok;
                 verifyCalculatedData(*m_series, &ok);
                 if (!ok)
                     return;
                 QCOMPARE(percentageSpy.count(), 1);
                 QCOMPARE(startAngleSpy.count(), 0);
                 QCOMPARE(angleSpanSpy.count(), 1);
                 // add some more slices
                 QList<QPieSlice *> list;
                 list << new QPieSlice("slice 2", 2);
                 list << new QPieSlice("slice 3", 3);
                 m_series->append(list);
                 verifyCalculatedData(*m_series, &ok);
                 if (!ok)
                     return;
                 QCOMPARE(percentageSpy.count(), 2);
                 QCOMPARE(startAngleSpy.count(), 0);
                 QCOMPARE(angleSpanSpy.count(), 2);
                 // remove a slice
                 m_series->remove(list.first()); // remove slice 2
                 verifyCalculatedData(*m_series, &ok);
                 if (!ok)
                     return;
                 QCOMPARE(percentageSpy.count(), 3);
                 QCOMPARE(startAngleSpy.count(), 0);
                 QCOMPARE(angleSpanSpy.count(), 3);
                 // insert a slice
                 m_series->insert(0, new QPieSlice("Slice 4", 4));
                 verifyCalculatedData(*m_series, &ok);
                 if (!ok)
                     return;
                 QCOMPARE(percentageSpy.count(), 4);
                 QCOMPARE(startAngleSpy.count(), 1);
                 QCOMPARE(angleSpanSpy.count(), 4);
                 // modify pie angles
                 m_series->setPieStartAngle(-90);
                 m_series->setPieEndAngle(90);
                 verifyCalculatedData(*m_series, &ok);
                 if (!ok)
                     return;
                 QCOMPARE(percentageSpy.count(), 4);
                 QCOMPARE(startAngleSpy.count(), 3);
                 QCOMPARE(angleSpanSpy.count(), 6);
                 // clear all
                 m_series->clear();
                 verifyCalculatedData(*m_series, &ok);
                 if (!ok)
                     return;
                 QCOMPARE(percentageSpy.count(), 4);
                 QCOMPARE(startAngleSpy.count(), 3);
                 QCOMPARE(angleSpanSpy.count(), 6);
             }
             void tst_qpieseries::verifyCalculatedData(const QPieSeries &series, bool *ok)
             {
                 *ok = false;
                 qreal sum = 0;
                 foreach (const QPieSlice *slice, series.slices())
                     sum += slice->value();
                 QCOMPARE(series.sum(), sum);
                 qreal startAngle = series.pieStartAngle();
                 qreal pieAngleSpan = series.pieEndAngle() - series.pieStartAngle();
                 foreach (const QPieSlice *slice, series.slices()) {
                     qreal ratio = slice->value() / sum;
                     qreal sliceSpan = pieAngleSpan * ratio;
                     QCOMPARE(slice->startAngle(), startAngle);
                     QCOMPARE(slice->angleSpan(), sliceSpan);
                     QCOMPARE(slice->percentage(), ratio);
                     startAngle += sliceSpan;
                 }
                 if (!series.isEmpty())
                     QCOMPARE(series.slices().last()->startAngle() + series.slices().last()->angleSpan(), series.pieEndAngle());
                 *ok = true;
             }
             void tst_qpieseries::clickedSignal()
             {
                 // add some slices
                 QPieSlice *s1 = m_series->append("slice 1", 1);
                 QPieSlice *s2 = m_series->append("slice 2", 1);
                 QPieSlice *s3 = m_series->append("slice 3", 1);
                 QPieSlice *s4 = m_series->append("slice 4", 1);
                 QSignalSpy clickSpy(m_series, SIGNAL(clicked(QPieSlice*)));
                 // add series to the chart
                 m_view->chart()->legend()->setVisible(false);
                 m_view->resize(200, 200);
                 m_view->chart()->addSeries(m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 // if you devide the chart in four equal tiles these
                 // are the center points of those tiles
                 QPoint p1(90.25, 90);
                 QPoint p2(150, 90);
                 QPoint p3(90, 150);
                 QPoint p4(150, 150);
                 QPoint center(120, 120);
                 m_series->setPieSize(1.0);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center);
                 TRY_COMPARE(clickSpy.count(), 5); // all hit
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(0).at(0)), s4);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(1).at(0)), s1);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(2).at(0)), s3);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(3).at(0)), s2);
                 clickSpy.clear();
                 m_series->setPieSize(0.5);
                 m_series->setVerticalPosition(0.25);
                 m_series->setHorizontalPosition(0.25);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1); // hits
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center);
                 TRY_COMPARE(clickSpy.count(), 1);
                 clickSpy.clear();
                 m_series->setVerticalPosition(0.25);
                 m_series->setHorizontalPosition(0.75);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2); // hits
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center);
                 TRY_COMPARE(clickSpy.count(), 1);
                 clickSpy.clear();
                 m_series->setVerticalPosition(0.75);
                 m_series->setHorizontalPosition(0.25);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3); // hits
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center);
                 TRY_COMPARE(clickSpy.count(), 1);
                 clickSpy.clear();
                 m_series->setVerticalPosition(0.75);
                 m_series->setHorizontalPosition(0.75);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3);
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4); // hits
                 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center);
                 TRY_COMPARE(clickSpy.count(), 1);
                 clickSpy.clear();
             }
             void tst_qpieseries::hoverSignal()
             {
                 // add some slices
                 m_series->setPieSize(1.0);
                 QPieSlice *s1 = m_series->append("slice 1", 1);
                 m_series->append("slice 2", 2);
                 m_series->append("slice 3", 3);
                 // add series to the chart
                 m_view->chart()->legend()->setVisible(false);
                 m_view->resize(200, 200);
                 m_view->chart()->addSeries(m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 // first move to right top corner
                 QTest::mouseMove(m_view->viewport(), QPoint(200, 0));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 // move inside the slice
                 // pie rectangle: QRectF(60,60 121x121)
                 QSignalSpy hoverSpy(m_series, SIGNAL(hovered(QPieSlice*,bool)));
                 QTest::mouseMove(m_view->viewport(), QPoint(139, 85));
                 TRY_COMPARE(hoverSpy.count(), 1);
                 QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(0).at(0)), s1);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(0).at(1)), true);
                 // move outside the slice
                 QTest::mouseMove(m_view->viewport(), QPoint(200, 0));
                 TRY_COMPARE(hoverSpy.count(), 2);
                 QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(1).at(0)), s1);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(1).at(1)), false);
             }
             void tst_qpieseries::sliceSeries()
             {
                 QPieSlice *slice = new QPieSlice();
                 QVERIFY(!slice->series());
                 delete slice;
                 slice = new QPieSlice(m_series);
                 QVERIFY(!slice->series());
                 m_series->append(slice);
                 QCOMPARE(slice->series(), m_series);
                 slice = new QPieSlice();
                 m_series->insert(0, slice);
                 QCOMPARE(slice->series(), m_series);
             }
             QTEST_MAIN(tst_qpieseries)
             #include "tst_qpieseries.moc"

tests/qmlchartproperties/qml/qmlchartproperties/PieEditor.qml 0 -5

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series
                 onSeriesChanged: {
                     if (series && series.name == "pie") {
                         seriesConnections.target = series;
                         sliceConnections.target = series.at(0);
                     } else {
                         seriesConnections.target = null;
                         sliceConnections.target = null;
                     }
                 }
                 Connections {
                     id: seriesConnections
                     target: null
                     onVisibleChanged:           console.log("series.onVisibleChanged: " + series.visible);
-                    onHorizontalPositionChanged:console.log("series.onHorizontalPositionChanged: " + series.horizontalPosition);
-                    onVerticalPositionChanged:  console.log("series.onVerticalPositionChanged: " + series.verticalPosition);
-                    onSizeChanged:              console.log("series.onSizeChanged: " + series.size);
-                    onStartAngleChanged:        console.log("series.onStartAngleChanged: " + series.startAngle);
-                    onEndAngleChanged:          console.log("series.onEndAngleChanged: " + series.endAngle);
                     onCountChanged:             console.log("series.onCountChanged: " + series.count);
                     onSumChanged:               console.log("series.onSumChanged: " + series.sum);
                 }
                 Connections {
                     id: sliceConnections
                     target: null
                     onValueChanged:             console.log("slice.onValueChanged: " + series.at(0).value);
                     onLabelVisibleChanged:      console.log("slice.onLabelVisibleChanged: " + series.at(0).labelVisible);
                     onLabelPositionChanged:     console.log("slice.onLabelPositionChanged: " + series.at(0).labelPosition);
                     onExplodedChanged:          console.log("slice.onExplodedChanged: " + series.at(0).exploded);
                     onPenChanged:               console.log("slice.onPenChanged: " + series.at(0).pen);
                     onBorderColorChanged:       console.log("slice.onBorderColorChanged: " + series.at(0).borderColor);
                     onBorderWidthChanged:       console.log("slice.onBorderWidthChanged: " + series.at(0).borderWidth);
                     onBrushChanged:             console.log("slice.onBrushChanged: " + series.at(0).brush);
                     onColorChanged:             console.log("slice.onColorChanged: " + series.at(0).color);
                     onLabelColorChanged:        console.log("slice.onLabelColorChanged: " + series.at(0).labelColor);
                     onLabelBrushChanged:        console.log("slice.onLabelBrushChanged: " + series.at(0).labelBrush);
                     onLabelFontChanged:         console.log("slice.onLabelFontChanged: " + series.at(0).labelFont);
                     onLabelArmLengthFactorChanged:  console.log("slice.onLabelArmLengthFactorChanged: " + series.at(0).labelArmLengthFactor);
                     onExplodeDistanceFactorChanged: console.log("slice.onExplodeDistanceFactorChanged: " + series.at(0).explodeDistanceFactor);
                     onPercentageChanged:        console.log("slice.onPercentageChanged: " + series.at(0).percentage);
                     onStartAngleChanged:        console.log("slice.onStartAngleChanged: " + series.at(0).startAngle);
                     onAngleSpanChanged:         console.log("slice.onAngleSpanChanged: " + series.at(0).angleSpan);
                     onClicked:                  console.log("slice.onClicked");
                     onHovered:                  console.log("slice.onHovered: " + state);
                 }
                 Button {
                     text: "visible"
                     onClicked: series.visible = !series.visible;
                 }
                 Button {
                     text: "series hpos +"
                     onClicked: series.horizontalPosition += 0.1;
                 }
                 Button {
                     text: "series hpos -"
                     onClicked: series.horizontalPosition -= 0.1;
                 }
                 Button {
                     text: "series vpos +"
                     onClicked: series.verticalPosition += 0.1;
                 }
                 Button {
                     text: "series vpos -"
                     onClicked: series.verticalPosition -= 0.1;
                 }
                 Button {
                     text: "series size +"
                     onClicked: series.size += 0.1;
                 }
                 Button {
                     text: "series size -"
                     onClicked: series.size -= 0.1;
                 }
                 Button {
                     text: "series start angle +"
                     onClicked: series.startAngle += 1.1;
                 }
                 Button {
                     text: "series start angle -"
                     onClicked: series.startAngle -= 1.1;
                 }
                 Button {
                     text: "series end angle +"
                     onClicked: series.endAngle += 1.1;
                 }
                 Button {
                     text: "series end angle -"
                     onClicked: series.endAngle -= 1.1;
                 }
                 Button {
                     text: "slice color"
                     onClicked: series.at(0).color = main.nextColor();
                 }
                 Button {
                     text: "slice border color"
                     onClicked: series.at(0).borderColor = main.nextColor();
                 }
                 Button {
                     text: "slice border width +"
                     onClicked: series.at(0).borderWidth++;
                 }
                 Button {
                     text: "slice border width -"
                     onClicked: series.at(0).borderWidth--;
                 }
                 Button {
                     text: "slice label visible"
                     onClicked: series.at(0).labelVisible = !series.at(0).labelVisible;
                 }
                 Button {
                     text: "slice label position inside"
                     onClicked: series.at(0).labelPosition = PieSlice.LabelInside;
                 }
                 Button {
                     text: "slice label position outside"
                     onClicked: series.at(0).labelPosition = PieSlice.LabelOutside;
                 }
                 Button {
                     text: "slice label arm len +"
                     onClicked: series.at(0).labelArmLengthFactor += 0.1;
                 }
                 Button {
                     text: "slice label arm len -"
                     onClicked: series.at(0).labelArmLengthFactor -= 0.1;
                 }
                 Button {
                     text: "slice label color"
                     onClicked: series.at(0).labelColor = main.nextColor();
                 }
                 Button {
                     text: "slice exploded"
                     onClicked: series.at(0).exploded = !series.at(0).exploded;
                 }
                 Button {
                     text: "slice explode dist +"
                     onClicked: series.at(0).explodeDistanceFactor += 0.1;
                 }
                 Button {
                     text: "slice explode dist -"
                     onClicked: series.at(0).explodeDistanceFactor -= 0.1;
                 }
             }

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