HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1531:658bb1d8ea02

QML signals documentation

Tero Ahola -

r1531:658bb1d8ea02

parent child

Context file:

r1531:658bb1d8ea02

Collapse all files

plugins/declarative/declarativechart.cpp +24 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$
             **
             ****************************************************************************/
             #include "declarativechart.h"
             #include <QPainter>
             #include "declarativelineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "declarativesplineseries.h"
             #include "declarativescatterseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \qmlclass ChartView DeclarativeChart
                 ChartView element is the parent that is responsible for showing different chart series types.
                 The following QML shows how to create a simple chart with one pie series:
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 1
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 2
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 3
                 \beginfloatleft
                 \image examples_qmlpiechart.png
                 \endfloat
                 \clearfloat
             */
             /*!
               \qmlproperty Theme ChartView::theme
               Theme defines the visual appearance of the chart, including for example colors, fonts, line
               widths and chart background.
             */
             /*!
               \qmlproperty Animation ChartView::animation
               Animation configuration of the chart. One of ChartView.NoAnimation, ChartView.GridAxisAnimations,
               ChartView.SeriesAnimations or ChartView.AllAnimations.
             */
             /*!
               \qmlproperty Font ChartView::titleFont
               The title font of the chart
               See the \l {Font} {QML Font Element} for detailed documentation.
             */
             /*!
               \qmlproperty string ChartView::title
               The title of the chart, shown on top of the chart.
               \sa ChartView::titleColor
             */
             /*!
               \qmlproperty string ChartView::titleColor
               The color of the title text.
             */
             /*!
               \qmlproperty Axis ChartView::axisX
               The x-axis of the chart.
             */
             /*!
               \qmlproperty Axis ChartView::axisY
               The default y-axis of the chart.
             */
             /*!
               \qmlproperty Legend ChartView::legend
               The legend of the chart. Legend lists all the series, pie slices and bar sets added on the chart.
             */
             /*!
               \qmlproperty int ChartView::count
               The count of series added to the chart.
             */
             /*!
               \qmlproperty color ChartView::backgroundColor
               The color of the chart's background. By default background color is defined by chart theme.
               \sa ChartView::theme
             */
             /*!
               \qmlproperty bool ChartView::dropShadowEnabled
               The chart's border drop shadow. Set to true to enable drop shadow.
             */
             /*!
               \qmlproperty real ChartView::topMargin
               The space between the top of chart view and the top of the plot area. The title (if non-empty) is drawn on top margin
               area of the chart view. Top margin area is also used by legend, if aligned to top.
             */
             /*!
               \qmlproperty real ChartView::bottomMargin
               The space between the bottom of chart view and the bottom of the plot area. The bottom margin area may be used by
               legend (if aligned to bottom), x-axis, x-axis labels and x-axis tick marks.
             */
             /*!
               \qmlproperty real ChartView::leftMargin
               The space between the left side of chart view and the left side of the plot area. The left margin area may be used by
               legend (if aligned to left), y-axis, y-axis labels and y-axis tick marks.
             */
             /*!
               \qmlproperty real ChartView::rightMargin
               The space between the right side of chart view and the right side of the plot area. The right margin area may be used
               by legend (if aligned to right).
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(int index)
               Returns the series with \a index on the chart. This allows you to loop through the series of a chart together with
               the count property of the chart.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(string name)
               Returns the first series on the chart with \a name. If there is no series with that name, returns null.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::createSeries(SeriesType type, string name)
               Creates a series object of \a type to the chart. For example:
               \code
                 var scatter = chartView.createSeries(ChartView.SeriesTypeScatter, "scatter series");
                 scatter.markerSize = 22;
                 scatter.append(1.1, 2.0);
               \endcode
             */
             /*!
               \qmlmethod Axis ChartView::axisY(QAbstractSeries *series)
               The y-axis of the series. This is the same as the default y-axis of the chart as multiple y-axes are not yet supported.
             */
             /*!
               \qmlmethod ChartView::zoomY(real factor)
               Zooms in by \a factor on the center of the chart.
             */
             /*!
               \qmlmethod ChartView::scrollLeft(real pixels)
               Scrolls to left by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa Axis::min, Axis::max
             */
             /*!
               \qmlmethod ChartView::scrollRight(real pixels)
               Scrolls to right by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa Axis::min, Axis::max
             */
             /*!
               \qmlmethod ChartView::scrollUp(real pixels)
               Scrolls up by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa Axis::min, Axis::max
             */
             /*!
               \qmlmethod ChartView::scrollDown(real pixels)
               Scrolls down by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa Axis::min, Axis::max
             */
+            /*!
+              \qmlsignal ChartView::onTopMarginChanged(real margin)
+              The top margin of the chart view has changed to \a margin. This may happen for example if you modify font size
+              related properties of the legend or chart title.
+            */
+            /*!
+              \qmlsignal ChartView::onBottomMarginChanged(real margin)
+              The bottom margin of the chart view has changed to \a margin. This may happen for example if you modify font size
+              related properties of the legend or chart title.
+            */
+            /*!
+              \qmlsignal ChartView::onLeftMarginChanged(real margin)
+              The left margin of the chart view has changed to \a margin. This may happen for example if you modify font size
+              related properties of the legend or chart title.
+            */
+            /*!
+              \qmlsignal ChartView::onRightMarginChanged(real margin)
+              The right margin of the chart view has changed to \a margin. This may happen for example if you modify font size
+              related properties of the legend or chart title.
+            */
             DeclarativeChart::DeclarativeChart(QDeclarativeItem *parent)
                 : QDeclarativeItem(parent),
                   m_chart(new QChart(this))
             {
                 setFlag(QGraphicsItem::ItemHasNoContents, false);
             //    m_chart->axisX()->setNiceNumbersEnabled(false);
                 m_chartMargins = m_chart->margins();
                 connect(m_chart, SIGNAL(marginsChanged(QRectF)), this, SLOT(handleMarginsChanged(QRectF)));
             }
             void DeclarativeChart::handleMarginsChanged(QRectF newMargins)
             {
                 if (m_chartMargins.top() != newMargins.top())
                     topMarginChanged(m_chart->margins().top());
                 if (m_chartMargins.bottom() != newMargins.bottom())
                     bottomMarginChanged(m_chart->margins().bottom());
                 if (m_chartMargins.left() != newMargins.left())
                     leftMarginChanged(m_chart->margins().left());
                 if (m_chartMargins.right() != newMargins.right())
                     rightMarginChanged(m_chart->margins().right());
                 m_chartMargins = m_chart->margins();
             }
             DeclarativeChart::~DeclarativeChart()
             {
                 delete m_chart;
             }
             void DeclarativeChart::childEvent(QChildEvent *event)
             {
                 if (event->type() == QEvent::ChildAdded) {
                     if (qobject_cast<QAbstractSeries *>(event->child())) {
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(event->child()));
                     }
                 }
             }
             void DeclarativeChart::componentComplete()
             {
                 foreach(QObject *child, children()) {
                     if (qobject_cast<QAbstractSeries *>(child)) {
             //            qDebug() << "DeclarativeChart::componentComplete(), add: " << child;
                         // TODO: how about optional y-axis?
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(child));
                     }
                 }
                 QDeclarativeItem::componentComplete();
             }
             void DeclarativeChart::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
             {
             //    qDebug() << "DeclarativeChart::geometryChanged" << newGeometry.width() << newGeometry.height();
                 if (newGeometry.isValid()) {
                     if (newGeometry.width() > 0 && newGeometry.height() > 0) {
                         m_chart->resize(newGeometry.width(), newGeometry.height());
                     }
                 }
                 QDeclarativeItem::geometryChanged(newGeometry, oldGeometry);
             }
             void DeclarativeChart::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 // TODO: optimized?
                 painter->setRenderHint(QPainter::Antialiasing, true);
             }
             void DeclarativeChart::setTheme(DeclarativeChart::Theme theme)
             {
                 QChart::ChartTheme chartTheme = (QChart::ChartTheme) theme;
                 if (chartTheme != m_chart->theme())
                     m_chart->setTheme(chartTheme);
             }
             DeclarativeChart::Theme DeclarativeChart::theme()
             {
                 return (DeclarativeChart::Theme) m_chart->theme();
             }
             void DeclarativeChart::setAnimationOptions(DeclarativeChart::Animation animations)
             {
                 QChart::AnimationOption animationOptions = (QChart::AnimationOption) animations;
                 if (animationOptions != m_chart->animationOptions())
                     m_chart->setAnimationOptions(animationOptions);
             }
             DeclarativeChart::Animation DeclarativeChart::animationOptions()
             {
                 if (m_chart->animationOptions().testFlag(QChart::AllAnimations))
                     return DeclarativeChart::AllAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::GridAxisAnimations))
                     return DeclarativeChart::GridAxisAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::SeriesAnimations))
                     return DeclarativeChart::SeriesAnimations;
                 else
                     return DeclarativeChart::NoAnimation;
             }
             void DeclarativeChart::setTitle(QString title)
             {
                 if (title != m_chart->title())
                     m_chart->setTitle(title);
             }
             QString DeclarativeChart::title()
             {
                 return m_chart->title();
             }
             QAxis *DeclarativeChart::axisX()
             {
                 return m_chart->axisX();
             }
             QAxis *DeclarativeChart::axisY(QAbstractSeries *series)
             {
                 return m_chart->axisY(series);
             }
             QLegend *DeclarativeChart::legend()
             {
                 return m_chart->legend();
             }
             QVariantList DeclarativeChart::axisXLabels()
             {
                 QVariantList labels;
                 foreach (qreal value, m_chart->axisX()->categories()->values()) {
                     labels.append(value);
                     labels.append(m_chart->axisX()->categories()->label(value));
                 }
                 return labels;
             }
             void DeclarativeChart::setAxisXLabels(QVariantList list)
             {
                 QVariant value(QVariant::Invalid);
                 foreach (QVariant element, list) {
                     if (value.isValid() && element.type() == QVariant::String) {
                         m_chart->axisX()->categories()->insert(value.toDouble(), element.toString());
                         value = QVariant(QVariant::Invalid);
                     } else {
                         if (element.canConvert(QVariant::Double))
                             value = element;
                     }
                 }
                 emit axisLabelsChanged();
             }
             void DeclarativeChart::setTitleColor(QColor color)
             {
                 QBrush b = m_chart->titleBrush();
                 if (color != b.color()) {
                     b.setColor(color);
                     m_chart->setTitleBrush(b);
                     emit titleColorChanged(color);
                 }
             }
             QFont DeclarativeChart::titleFont() const
             {
                 return m_chart->titleFont();
             }
             void DeclarativeChart::setTitleFont(const QFont& font)
             {
                 m_chart->setTitleFont(font);
             }
             QColor DeclarativeChart::titleColor()
             {
                 return m_chart->titleBrush().color();
             }
             void DeclarativeChart::setBackgroundColor(QColor color)
             {
                 QBrush b = m_chart->backgroundBrush();
                 if (b.style() != Qt::SolidPattern || color != b.color()) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setBackgroundBrush(b);
                     emit backgroundColorChanged();
                 }
             }
             QColor DeclarativeChart::backgroundColor()
             {
                 return m_chart->backgroundBrush().color();
             }
             int DeclarativeChart::count()
             {
                 return m_chart->series().count();
             }
             void DeclarativeChart::setDropShadowEnabled(bool enabled)
             {
                 if (enabled != m_chart->isDropShadowEnabled()) {
                     m_chart->setDropShadowEnabled(enabled);
                     dropShadowEnabledChanged(enabled);
                 }
             }
             bool DeclarativeChart::dropShadowEnabled()
             {
                 return m_chart->isDropShadowEnabled();
             }
             qreal DeclarativeChart::topMargin()
             {
                 return m_chart->margins().top();
             }
             qreal DeclarativeChart::bottomMargin()
             {
                 return m_chart->margins().bottom();
             }
             qreal DeclarativeChart::leftMargin()
             {
                 return m_chart->margins().left();
             }
             qreal DeclarativeChart::rightMargin()
             {
                 return m_chart->margins().right();
             }
             void DeclarativeChart::zoom(qreal factor)
             {
                 m_chart->zoom(factor);
             }
             void DeclarativeChart::scrollLeft(qreal pixels)
             {
                 m_chart->scroll(QPointF(pixels, 0));
             }
             void DeclarativeChart::scrollRight(qreal pixels)
             {
                 m_chart->scroll(QPointF(-pixels, 0));
             }
             void DeclarativeChart::scrollUp(qreal pixels)
             {
                 m_chart->scroll(QPointF(0, pixels));
             }
             void DeclarativeChart::scrollDown(qreal pixels)
             {
                 m_chart->scroll(QPointF(0, -pixels));
             }
             QAbstractSeries *DeclarativeChart::series(int index)
             {
                 if (index < m_chart->series().count()) {
                     return m_chart->series().at(index);
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::series(QString seriesName)
             {
                 foreach(QAbstractSeries *series, m_chart->series()) {
                     if (series->name() == seriesName)
                         return series;
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::createSeries(DeclarativeChart::SeriesType type, QString name)
             {
                 QAbstractSeries *series = 0;
                 switch (type) {
                 case DeclarativeChart::SeriesTypeLine:
                     series = new DeclarativeLineSeries();
                     break;
                 case DeclarativeChart::SeriesTypeArea:
                     series = new DeclarativeAreaSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBar:
                     series = new DeclarativeBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeStackedBar:
                     // TODO
                     break;
                 case DeclarativeChart::SeriesTypePercentBar:
                     // TODO
                     break;
                 case DeclarativeChart::SeriesTypeGroupedBar:
                     series = new DeclarativeGroupedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypePie:
                     series = new DeclarativePieSeries();
                     break;
                 case DeclarativeChart::SeriesTypeScatter:
                     series = new DeclarativeScatterSeries();
                     break;
                 case DeclarativeChart::SeriesTypeSpline:
                     series = new DeclarativeSplineSeries();
                     break;
                 default:
                     qWarning() << "Illegal series type";
                 }
                 series->setName(name);
                 m_chart->addSeries(series);
                 return series;
             }
             #include "moc_declarativechart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/qareaseries.cpp +4 -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 "qareaseries.h"
             #include "qareaseries_p.h"
             #include "qlineseries.h"
             #include "areachartitem_p.h"
             #include "legendmarker_p.h"
             #include "domain_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAreaSeries
                 \brief The QAreaSeries class is used for making area charts.
                 \mainclass
             	An area chart is used to show quantitative data. It is based on line chart, in the way that area between axis and the line
             	is emphasized with color. Since the area chart is based on line chart, QAreaSeries constructor needs QLineSeries instance,
             	which defines "upper" boundary of the area. "Lower" boundary is defined by default by axis X. Instead of axis X "lower" boundary can be specified by other line.
                 In that case QAreaSeries should be initiated with two QLineSeries instances. Please note terms "upper" and "lower" boundary can be misleading in cases
             	where "lower" boundary had bigger values than the "upper" one, however the main point that area between these two boundary lines will be filled.
                 See the \l {AreaChart Example} {area chart example} to learn how to create a simple area chart.
                 \image examples_areachart.png
             */
             /*!
                 \qmlclass AreaSeries QAreaSeries
                 The following QML shows how to create a simple area chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View4.qml 1
                 \beginfloatleft
                 \image demos_qmlchart4.png
                 \endfloat
                 \clearfloat
             */
             /*!
                \property QAreaSeries::upperSeries
                \brief The upper one of the two line series used to define area series boundaries.
             */
             /*!
                \qmlproperty LineSeries AreaSeries::upperSeries
                The upper one of the two line series used to define area series boundaries.
             */
             /*!
                 \property QAreaSeries::lowerSeries
                 The lower one of the two line series used to define are series boundaries. Note if
                 QAreaSeries was counstucted wihtout a\ lowerSeries this is null.
             */
             /*!
                 \qmlproperty LineSeries AreaSeries::lowerSeries
                 The lower one of the two line series used to define are series boundaries. Note if
                 AreaSeries was counstucted wihtout a\ lowerSeries this is null.
             */
             /*!
                 \property QAreaSeries::color
                 Fill (brush) color of the series. This is a convenience property for modifying the color of brush.
                 \sa QAreaSeries::brush()
             */
             /*!
                 \qmlproperty color AreaSeries::color
                 Fill (brush) color of the series.
             */
             /*!
                 \property QAreaSeries::borderColor
                 Line (pen) color of the series. This is a convenience property for modifying the color of pen.
                 \sa QAreaSeries::pen()
             */
             /*!
                 \qmlproperty color AreaSeries::borderColor
                 Line (pen) color of the series.
             */
             /*!
                \fn QPen QAreaSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn QPen QAreaSeries::brush() const
                \brief  Returns the brush used to draw line for this series.
                 \sa setBrush()
             */
             /*!
                 \fn void QAreaSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the fill (brush) color has changed to \a color.
             */
             /*!
-                \qmlsignal AreaSeries::colorChanged(color color)
+                \qmlsignal AreaSeries::onColorChanged(color color)
                 Signal is emitted when the fill (brush) color has changed to \a color.
             */
             /*!
                 \fn void QAreaSeries::borderColorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
-                \qmlsignal AreaSeries::borderColorChanged(color color)
+                \qmlsignal AreaSeries::onBorderColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn void QAreaSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on area chart.
             */
             /*!
-                \qmlsignal AreaSeries::clicked(QPointF point)
+                \qmlsignal AreaSeries::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on area chart.
             */
             /*!
                 \fn void QAreaSeries::selected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of QAreaSeries API.
             */
             /*!
-                \qmlsignal AreaSeries::selected()
+                \qmlsignal AreaSeries::onSelected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of AreaSeries API.
             */
             /*!
                 \fn void QAreaSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 Constructs area series object which is a child of \a upperSeries. Area will be spanned between \a
                 upperSeries line and \a lowerSeries line.  If no \a lowerSeries is passed to constructor, area is specified by axis x (y=0) instead.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QAreaSeries::QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries)
                 : QAbstractSeries(*new QAreaSeriesPrivate(upperSeries,lowerSeries,this),upperSeries)
             {
             }
             /*!
                 Constructs area series object without upper or lower series with \a parent object.
             */
             QAreaSeries::QAreaSeries(QObject *parent)
                 : QAbstractSeries(*new QAreaSeriesPrivate(0, 0, this), parent)
             {
             }
             /*!
                 Destroys the object.
             */
             QAreaSeries::~QAreaSeries()
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypeArea.
             */
             QAbstractSeries::SeriesType QAreaSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeArea;
             }
             /*!
                 Sets the \a series that is to be used as the area chart upper series.
             */
             void QAreaSeries::setUpperSeries(QLineSeries* series)
             {
                 Q_D(QAreaSeries);
                 d->m_upperSeries = series;
             }
             QLineSeries* QAreaSeries::upperSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_upperSeries;
             }
             /*!
                 Sets the \a series that is to be used as the area chart lower series.
             */
             void QAreaSeries::setLowerSeries(QLineSeries* series)
             {
                 Q_D(QAreaSeries);
                 d->m_lowerSeries = series;
             }
             QLineSeries* QAreaSeries::lowerSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_lowerSeries;
             }
             /*!
                 Sets \a pen used for drawing area outline.
             */
             void QAreaSeries::setPen(const QPen &pen)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pen != pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen  QAreaSeries::pen() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for filling the area.
             */
             void QAreaSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QAreaSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QAreaSeries::brush() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_brush;
             }
             void QAreaSeries::setColor(const QColor &color)
             {
                 QBrush b = brush();
                 if (b.color() != color) {
                     b.setColor(color);
                     setBrush(b);
                     emit colorChanged(color);
                 }
             }
             QColor QAreaSeries::color() const
             {
                 return brush().color();
             }
             void QAreaSeries::setBorderColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             QColor QAreaSeries::borderColor() const
             {
                 return pen().color();
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QAreaSeries::setPointsVisible(bool visible)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             /*!
                 Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             bool QAreaSeries::pointsVisible() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointsVisible;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries,QAreaSeries* q) :
                 QAbstractSeriesPrivate(q),
                 m_upperSeries(upperSeries),
                 m_lowerSeries(lowerSeries),
                 m_pointsVisible(false)
             {
             }
             void QAreaSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_Q(QAreaSeries);
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 QLineSeries* upperSeries = q->upperSeries();
                 QLineSeries* lowerSeries = q->lowerSeries();
                 const QList<QPointF>& points = upperSeries->points();
                 for (int i = 0; i < points.count(); i++)
                 {
                     qreal x = points[i].x();
                     qreal y = points[i].y();
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                 if(lowerSeries) {
                     const QList<QPointF>& points = lowerSeries->points();
                     for (int i = 0; i < points.count(); i++)
                     {
                         qreal x = points[i].x();
                         qreal y = points[i].y();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                     }}
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QAreaSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem* area = new AreaChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     area->upperLineItem()->setAnimator(presenter->animator());
                     area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem()));
                     if(q->lowerSeries())  {
                         area->lowerLineItem()->setAnimator(presenter->animator());
                         area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem()));
                     }
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return area;
             }
             QList<LegendMarker*> QAreaSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QAreaSeries);
                 QList<LegendMarker*> list;
                 return list << new AreaLegendMarker(q,legend);
             }
             #include "moc_qareaseries.cpp"
             #include "moc_qareaseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qaxis.cpp +15 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$
             **
             ****************************************************************************/
             #include "qaxis.h"
             #include "qaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAxis
                 \brief The QAxis class is used for manipulating chart's axis
                 and for adding optional axes to the chart.
                 \mainclass
                 There is only one x Axis, however there can be multiple y axes.
                 Each chart series can be bound to exactly one Y axis and the shared common X axis.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass Axis QAxis
                 \brief The Axis element is used for manipulating chart's axes
                 There is only one x Axis, however there can be multiple y axes on a ChartView.
                 Each chart series can be bound to exactly one Y axis and the shared common X axis.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         axisX.min: 0
                         axisX.max: 3
                         axisX.ticksCount: 4
                         axisY.min: 0
                         axisY.max: 4
                         // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \qmlproperty bool Axis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \property QAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \qmlproperty real Axis::min
               Defines the minimum value on the axis.
             */
             /*!
               \property QAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \qmlproperty real Axis::max
               Defines the maximum value on the axis.
             */
             /*!
               \property QAxis::visible
               The visibility of the axis.
             */
             /*!
               \qmlproperty bool Axis::visible
               The visibility of the axis.
             */
             /*!
               \property QAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \qmlproperty bool Axis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \property QAxis::color
               The color of the axis and ticks.
             */
             /*!
               \qmlproperty color Axis::color
               The color of the axis and ticks.
             */
             /*!
               \property QAxis::labelsFont
               The font of the axis labels.
             */
             /*!
               \qmlproperty Font Axis::labelsFont
               The font of the axis labels.
               See the \l {Font} {QML Font Element} for detailed documentation.
             */
             /*!
               \property QAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \qmlproperty color Axis::labelsColor
               The color of the axis labels.
             */
             /*!
               \property QAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \qmlproperty int Axis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \property QAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \qmlproperty bool Axis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \property QAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \qmlproperty color Axis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \property QAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \qmlproperty color Axis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \property QAxis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \qmlproperty int Axis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \property QAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
               \qmlproperty bool Axis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
               \fn void QAxis::visibleChanged(bool)
               Visiblity of the axis has changed to \a visible.
             */
             /*!
               \fn void QAxis::labelsVisibleChanged(bool)
               Visiblity of the labels of the axis has changed to \a visible.
             */
             /*!
               \fn void QAxis::gridVisibleChanged(bool)
               Visiblity of the grid lines of the axis has changed to \a visible.
             */
             /*!
               \fn void QAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
+            /*!
+              \qmlsignal Axis::onMinChanged(real min)
+              Axis emits signal when \a min of axis has changed. This may happen for example if you zoom, scroll or
+              enable nice numbers algorithm.
+            */
             /*!
               \fn void QAxis::maxChanged(qreal max)
               Axis emits signal when \a max of axis has changed.
             */
+            /*!
+              \qmlsignal Axis::onMaxChanged(real max)
+              Axis emits signal when \a max of axis has changed. This may happen for example if you zoom, scroll or
+              enable nice numbers algorithm.
+            */
             /*!
               \fn void QAxis::rangeChanged(qreal min, qreal max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
+            /*!
+              \qmlsignal Axis::onRangeChanged(real min, real max)
+              Axis emits signal when \a min or \a max of axis has changed. This may happen for example if you zoom, scroll or
+              enable nice numbers algorithm.
+            */
             /*!
               \fn QChartAxisCategories* QAxis::categories()
               Returns pointer to the list of categories which correspond to the values on the axis.
             */
             /*!
               \fn void QAxis::colorChanged(QColor)
               Emitted if the \a color of the axis is changed.
             */
             /*!
               \fn void QAxis::labelsColorChanged(QColor)
               Emitted if the \a color of the axis labels is changed.
             */
             /*!
               \fn void QAxis::shadesVisibleChanged(bool)
               Emitted if the visibility of the axis shades is changed to \a visible.
             */
             /*!
               \fn void QAxis::shadesColorChanged(QColor)
               Emitted if the \a color of the axis shades is changed.
             */
             /*!
               \fn void QAxis::shadesBorderColorChanged(QColor)
               Emitted if the border \a color of the axis shades is changed.
             */
             /*!
               Constructs new axis object which is a child of \a parent. Ownership is taken by
               QChart when axis added.
             */
             QAxis::QAxis(QObject *parent) : QObject(parent),
             d_ptr(new QAxisPrivate(this))
             {
             }
             /*!
               Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
             QAxis::~QAxis()
             {
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
             void QAxis::setAxisPen(const QPen &pen)
             {
             	if (d_ptr->m_axisPen!=pen) {
             	    d_ptr->m_axisPen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns pen used to draw axis and ticks.
             */
             QPen QAxis::axisPen() const
             {
                 return d_ptr->m_axisPen;
             }
             void QAxis::setAxisPenColor(QColor color)
             {
                 QPen p = d_ptr->m_axisPen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setAxisPen(p);
                     emit colorChanged(color);
                 }
             }
             QColor QAxis::axisPenColor() const
             {
                 return d_ptr->m_axisPen.color();
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
             void QAxis::setAxisVisible(bool visible)
             {
                 if (d_ptr->m_axisVisible != visible) {
                     d_ptr->m_axisVisible = visible;
                     emit d_ptr->updated();
                     emit visibleChanged(visible);
             	}
             }
             bool QAxis::isAxisVisible() const
             {
                 return d_ptr->m_axisVisible;
             }
             void QAxis::setGridLineVisible(bool visible)
             {
                 if (d_ptr->m_gridLineVisible != visible) {
                     d_ptr->m_gridLineVisible = visible;
                     emit d_ptr->updated();
                     emit gridVisibleChanged(visible);
             	}
             }
             bool QAxis::isGridLineVisible() const
             {
                 return d_ptr->m_gridLineVisible;
             }
             /*!
               Sets \a pen used to draw grid line.
             */
             void QAxis::setGridLinePen(const QPen &pen)
             {
                 if (d_ptr->m_gridLinePen != pen) {
                     d_ptr->m_gridLinePen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns pen used to draw grid.
             */
             QPen QAxis::gridLinePen() const
             {
                 return d_ptr->m_gridLinePen;
             }
             void QAxis::setLabelsVisible(bool visible)
             {
                 if (d_ptr->m_labelsVisible != visible) {
                     d_ptr->m_labelsVisible = visible;
                     emit d_ptr->updated();
                     emit labelsVisibleChanged(visible);
             	}
             }
             bool QAxis::labelsVisible() const
             {
                 return d_ptr->m_labelsVisible;
             }
             /*!
               Sets \a pen used to draw labels.
             */
             void QAxis::setLabelsPen(const QPen &pen)
             {
                 if (d_ptr->m_labelsPen != pen) {
                     d_ptr->m_labelsPen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns the pen used to labels.
             */
             QPen QAxis::labelsPen() const
             {
                 return d_ptr->m_labelsPen;
             }
             /*!
               Sets \a brush used to draw labels.
              */
             void QAxis::setLabelsBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelsBrush != brush) {
                     d_ptr->m_labelsBrush = brush;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns brush used to draw labels.
             */
             QBrush  QAxis::labelsBrush() const
             {
                 return d_ptr->m_labelsBrush;
             }
             /*!
               Sets \a font used to draw labels.
             */
             void QAxis::setLabelsFont(const QFont &font)
             {
                 if (d_ptr->m_labelsFont != font) {
                     d_ptr->m_labelsFont = font;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns font used to draw labels.
             */
             QFont QAxis::labelsFont() const
             {
                 return d_ptr->m_labelsFont;
             }
             void QAxis::setLabelsAngle(int angle)
             {
                 if (d_ptr->m_labelsAngle != angle) {
                     d_ptr->m_labelsAngle = angle;
                     emit d_ptr->updated();
             	}
             }
             int QAxis::labelsAngle() const
             {
                 return d_ptr->m_labelsAngle;
             }
             void QAxis::setLabelsColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelsBrush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setLabelsBrush(b);
                     emit labelsColorChanged(color);
                 }
             }
             QColor QAxis::labelsColor() const
             {
                 return d_ptr->m_labelsBrush.color();
             }
             void QAxis::setShadesVisible(bool visible)
             {
                 if (d_ptr->m_shadesVisible != visible) {
                     d_ptr->m_shadesVisible = visible;
                     emit d_ptr->updated();
                     emit shadesVisibleChanged(visible);
             	}
             }
             bool QAxis::shadesVisible() const
             {
                 return d_ptr->m_shadesVisible;
             }
             /*!
               Sets \a pen used to draw shades.
             */
             void QAxis::setShadesPen(const QPen &pen)
             {
                 if (d_ptr->m_shadesPen != pen) {
                     d_ptr->m_shadesPen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns pen used to draw shades.
             */
             QPen QAxis::shadesPen() const
             {
                 return d_ptr->m_shadesPen;
             }
             /*!
               Sets \a brush used to draw shades.
             */
             void QAxis::setShadesBrush(const QBrush &brush)
             {
                 if (d_ptr->m_shadesBrush != brush) {
                     d_ptr->m_shadesBrush = brush;
                     emit d_ptr->updated();
                     emit shadesColorChanged(brush.color());
                 }
             }
             /*!
                \brief Returns brush used to draw shades.
             */
             QBrush QAxis::shadesBrush() const
             {
                 return d_ptr->m_shadesBrush;
             }
             void QAxis::setShadesColor(QColor color)
             {
                 QBrush b = d_ptr->m_shadesBrush;
                 b.setColor(color);
                 setShadesBrush(b);
             }
             QColor QAxis::shadesColor() const
             {
                 return d_ptr->m_shadesBrush.color();
             }
             void QAxis::setShadesBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_shadesPen;
                 p.setColor(color);
                 setShadesPen(p);
             }
             QColor QAxis::shadesBorderColor() const
             {
                 return d_ptr->m_shadesPen.color();
             }
             void QAxis::setMin(qreal min)
             {
             	setRange(min,d_ptr->m_max);
             }
             qreal QAxis::min() const
             {
                 return d_ptr->m_min;
             }
             void QAxis::setMax(qreal max)
             {
                 setRange(d_ptr->m_min,max);
             }
             qreal QAxis::max() const
             {
                 return d_ptr->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
             */
             void QAxis::setRange(qreal min, qreal max)
             {
             	bool changed = false;
                 if (!qFuzzyIsNull(d_ptr->m_min - min)) {
                     d_ptr->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
                 if (!qFuzzyIsNull(d_ptr->m_max - max)) {
                     d_ptr->m_max = max;
                     changed = true;
                     emit maxChanged(max);
                 }
                 if (changed) {
                     emit rangeChanged(d_ptr->m_min,d_ptr->m_max);
                     emit d_ptr->changed(d_ptr->m_min, d_ptr->m_max, d_ptr->m_ticksCount, d_ptr->m_niceNumbers);
                 }
             }
             /*!
               Sets \a count for ticks on the axis.
             */
             void QAxis::setTicksCount(int count)
             {
                 if (d_ptr->m_ticksCount != count) {
                     d_ptr->m_ticksCount = count;
             		emit d_ptr->changed(d_ptr->m_min, d_ptr->m_max, d_ptr->m_ticksCount, d_ptr->m_niceNumbers);
             	}
             }
             /*!
               \fn int QAxis::ticksCount() const
               Return number of ticks on the axis
             */
             int QAxis::ticksCount() const
             {
                 return d_ptr->m_ticksCount;
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAxis::show()
             {
                 d_ptr->m_axisVisible=true;
                 d_ptr->m_gridLineVisible=true;
                 d_ptr->m_labelsVisible=true;
                 d_ptr->m_shadesVisible=true;
                 emit d_ptr->updated();
             }
             /*!
               Sets axis, shades, labels and grid lines to not be visible.
             */
             void QAxis::hide()
             {
                 d_ptr->m_axisVisible = false;
                 d_ptr->m_gridLineVisible = false;
                 d_ptr->m_labelsVisible = false;
                 d_ptr->m_shadesVisible = false;
                 emit d_ptr->updated();
             }
             void QAxis::setNiceNumbersEnabled(bool enable)
             {
                 if (d_ptr->m_niceNumbers != enable){
                     d_ptr->m_niceNumbers = enable;
                     emit d_ptr->changed(d_ptr->m_min, d_ptr->m_max, d_ptr->m_ticksCount, d_ptr->m_niceNumbers);
                 }
             }
             bool  QAxis::niceNumbersEnabled() const
             {
                 return d_ptr->m_niceNumbers;
             }
             QAxisCategories* QAxis::categories()
             {
                 return &d_ptr->m_category;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAxisPrivate::QAxisPrivate(QAxis* q):
                 q_ptr(q),
                 m_axisVisible(true),
                 m_gridLineVisible(true),
                 m_labelsVisible(true),
                 m_labelsAngle(0),
                 m_shadesVisible(false),
                 m_shadesBrush(Qt::SolidPattern),
                 m_shadesOpacity(1.0),
                 m_min(0),
                 m_max(0),
                 m_ticksCount(5),
                 m_niceNumbers(false)
             {
             }
             QAxisPrivate::~QAxisPrivate()
             {
             }
             void QAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                q_ptr->setRange(min,max);
                q_ptr->setTicksCount(count);
             }
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             #include "moc_qaxis.cpp"
             #include "moc_qaxis_p.cpp"

src/barchart/qbarseries.cpp +3 -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$
             **
             ****************************************************************************/
             #include "qbarseries.h"
             #include "qbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief Series for creating a bar chart
                 \mainclass
                 QBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars to
                 the position defined by data. Single bar is defined by QPointF, where x value is the x-coordinate of the bar
                 and y-value is the height of the bar. The category names are ignored with this series and x-axis
                 shows the x-values.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \qmlclass BarSeries QBarSeries
                 \inherits AbstractSeries
                 The following QML shows how to create a simple bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View6.qml 1
                 \beginfloatleft
                 \image demos_qmlchart6.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \property QBarSeries::barWidth
                 The width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with QGroupedBarSeries this value means the width of one group of bars instead of just one bar.
                 \sa QGroupedBarSeries
             */
             /*!
                 \qmlproperty real BarSeries::barWidth
                 The width of the bars of the series. The unit of width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with QGroupedBarSeries this value means the width of one group of bars instead of just one bar.
             */
             /*!
                 \property QBarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \qmlproperty int BarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \property QBarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \qmlproperty bool BarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \fn void QBarSeries::clicked(QBarSet *barset, int index)
                 The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \qmlsignal BarSeries::onClicked(BarSet barset, int index)
                 The signal is emitted if the user clicks with a mouse on top of BarSet.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \fn void QBarSeries::hovered(QBarSet* barset, bool status)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 \qmlsignal BarSeries::onHovered(BarSet barset, bool status)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 \fn void QBarSeries::countChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
-                \qmlsignal BarSeries::countChanged()
+                \qmlsignal BarSeries::onCountChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \fn void QBarSeries::labelsVisibleChanged()
                 This signal is emitted when labels visibility have changed.
                 \sa isLabelsVisible(), setLabelsVisible()
             */
             /*!
                 \fn void QBarSeries::barsetsAdded(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been added to the series.
                 \sa append(), insert()
             */
             /*!
-                \qmlsignal BarSeries::added(BarSet barset)
+                \qmlsignal BarSeries::onAdded(BarSet barset)
                 Emitted when \a barset has been added to the series.
             */
             /*!
                 \fn void QBarSeries::barsetsRemoved(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been removed from the series.
                 \sa remove()
             */
             /*!
-                \qmlsignal BarSeries::removed(BarSet barset)
+                \qmlsignal BarSeries::onRemoved(BarSet barset)
                 Emitted when \a barset has been removed from the series.
             */
             /*!
                 \qmlmethod BarSet BarSeries::at(int index)
                 Returns bar set at \a index. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod BarSet BarSeries::append(string label, VariantList values)
                 Adds a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XyPoints.
                 For example:
                 \code
                     myBarSeries.append("set 1", [0, 0.2, 0.2, 0.5, 0.4, 1.5, 0.9]);
                     myBarSeries.append("set 2", [Qt.point(0, 1), Qt.point(2, 2.5), Qt.point(3.5, 2.2)]);
                 \endcode
             */
             /*!
                 \qmlmethod BarSet BarSeries::insert(int index, string label, VariantList values)
                 Inserts a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XyPoints.
                 If index is zero or smaller, the new barset is prepended. If the index is count or bigger, the new barset is
                 appended.
                 \sa BarSeries::append()
             */
             /*!
                 \qmlmethod bool BarSeries::remove(BarSet barset)
                 Removes the barset from the series. Returns true if successfull, false otherwise.
             */
             /*!
                 \qmlmethod BarSeries::clear()
                 Removes all barsets from the series.
             */
             /*!
                 Constructs empty QBarSeries.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QObject *parent) :
                 QAbstractSeries(*new QBarSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destructs barseries and owned barsets.
             */
             QBarSeries::~QBarSeries()
             {
                 Q_D(QBarSeries);
                 if(d->m_dataset){
                     d->m_dataset->removeSeries(this);
                 }
             }
             /*!
                 \internal
             */
             QBarSeries::QBarSeries(QBarSeriesPrivate &d, QObject *parent) :
                 QAbstractSeries(d,parent)
             {
             }
             /*!
                 Returns the type of series. Derived classes override this.
             */
             QAbstractSeries::SeriesType QBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBar;
             }
             /*!
                 Sets the width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with \link QGroupedBarSeries \endlink this value means the width of one group of bars instead of just one bar.
             */
             void QBarSeries::setBarWidth(qreal width)
             {
                 Q_D(QBarSeries);
                 d->setBarWidth(width);
             }
             /*!
                 Returns the width of the bars of the series.
                 \sa setBarWidth()
             */
             qreal QBarSeries::barWidth() const
             {
                 Q_D(const QBarSeries);
                 return d->barWidth();
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if appending succeeded.
             */
             bool QBarSeries::append(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 bool success = d->append(set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesn't delete \a set.
                 Returns true, if set was removed.
             */
             bool QBarSeries::remove(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsRemoved(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Adds a list of barsets to series. Takes ownership of \a sets.
                 Returns true, if all sets were appended succesfully. If any of the sets is null or is already appended to series,
                 nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
                 and function returns false.
             */
             bool QBarSeries::append(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
                 bool success = d->append(sets);
                 if (success) {
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Insert a set of bars to series at \a index postion. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if inserting succeeded.
             */
             bool QBarSeries::insert(int index, QBarSet *set)
             {
                 Q_D(QBarSeries);
                 bool success = d->insert(index, set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes all of the bar sets from the series
             */
             void QBarSeries::clear()
             {
                 Q_D(QBarSeries);
                 QList<QBarSet *> sets = barSets();
                 bool success = d->remove(sets);
                 if (success) {
                     emit barsetsRemoved(sets);
                     emit countChanged();
                 }
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::count() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets;
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QBarSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QBarSeries);
                 if (d->m_labelsVisible != visible) {
                     d->setLabelsVisible(visible);
                     emit labelsVisibleChanged();
                 }
             }
             /*!
                 Returns the visibility of labels
             */
             bool QBarSeries::isLabelsVisible() const
             {
                 Q_D(const QBarSeries);
                 return d->m_labelsVisible;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barWidth(0.5),  // Default value is 50% of category width
                 m_labelsVisible(false),
                 m_visible(true)
             {
             }
             int QBarSeriesPrivate::categoryCount() const
             {
                 // No categories defined. return count of longest set.
                 int count = 0;
                 for (int i=0; i<m_barSets.count(); i++) {
                     if (m_barSets.at(i)->count() > count) {
                         count = m_barSets.at(i)->count();
                     }
                 }
                 return count;
             }
             void QBarSeriesPrivate::setBarWidth(qreal width)
             {
                 if (width < 0.0) {
                     width = 0.0;
                 }
                 m_barWidth = width;
                 emit updatedBars();
             }
             qreal QBarSeriesPrivate::barWidth() const
             {
                 return m_barWidth;
             }
             QBarSet* QBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             void QBarSeriesPrivate::setVisible(bool visible)
             {
                 m_visible = visible;
                 emit updatedBars();
             }
             void QBarSeriesPrivate::setLabelsVisible(bool visible)
             {
                 m_labelsVisible = visible;
                 emit labelsVisibleChanged(visible);
             }
             qreal QBarSeriesPrivate::min()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j).y();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QBarSeriesPrivate::max()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j).y();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QBarSeriesPrivate::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 return m_barSets.at(set)->at(category).y();
             }
             qreal QBarSeriesPrivate::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 qreal value = m_barSets.at(set)->at(category).y();
                 qreal sum = categorySum(category);
                 if ( qFuzzyIsNull(sum) ) {
                     return 0;
                 }
                 return value / sum;
             }
             qreal QBarSeriesPrivate::categorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += m_barSets.at(set)->at(category).y();
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::absoluteCategorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += qAbs(m_barSets.at(set)->at(category).y());
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal sum = categorySum(i);
                     if (sum > max)
                         max = sum;
                 }
                 return max;
             }
             qreal QBarSeriesPrivate::minX()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j).x();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QBarSeriesPrivate::maxX()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j).x();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             void QBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 qreal seriesMinX = this->minX();
                 qreal seriesMaxX = this->maxX();
                 qreal y = max();
                 minX = qMin(minX, seriesMinX - 0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, seriesMaxX + 0.5);
                 maxY = qMax(maxY, y);
                 tickXCount = categoryCount()+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QBarSeries);
                 BarChartItem* bar = new BarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             QList<LegendMarker*> QBarSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QBarSeries);
                 QList<LegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     BarLegendMarker* marker = new BarLegendMarker(q,set,legend);
                     markers << marker;
                 }
                 return markers;
             }
             bool QBarSeriesPrivate::append(QBarSet *set)
             {
                 Q_Q(QBarSeries);
                 if ((m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;
                 }
                 m_barSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();      // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QBarSeriesPrivate::remove(QBarSet *set)
             {
                 Q_Q(QBarSeries);
                 if (!m_barSets.contains(set)) {
                     // Fail if set is not in list
                     return false;
                 }
                 m_barSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();        // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QBarSeriesPrivate::append(QList<QBarSet* > sets)
             {
                 Q_Q(QBarSeries);
                 foreach (QBarSet* set, sets) {
                     if ((set == 0) || (m_barSets.contains(set))) {
                         // Fail if any of the sets is null or is already appended.
                         return false;
                     }
                     if (sets.count(set) != 1) {
                         // Also fail if same set is more than once in given list.
                         return false;
                     }
                 }
                 foreach (QBarSet* set, sets) {
                     m_barSets.append(set);
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QBarSeriesPrivate::remove(QList<QBarSet* > sets)
             {
                 Q_Q(QBarSeries);
                 if (sets.count() == 0) {
                     return false;
                 }
                 foreach (QBarSet* set, sets) {
                     if ((set == 0) || (!m_barSets.contains(set))) {
                         // Fail if any of the sets is null or is not in series
                         return false;
                     }
                     if (sets.count(set) != 1) {
                         // Also fail if same set is more than once in given list.
                         return false;
                     }
                 }
                 foreach (QBarSet* set, sets) {
                     m_barSets.removeOne(set);
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QBarSeriesPrivate::insert(int index, QBarSet *set)
             {
                 Q_Q(QBarSeries);
                 if ((m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;
                 }
                 m_barSets.insert(index, set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();      // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             #include "moc_qbarseries.cpp"
             #include "moc_qbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.cpp +4 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$
             **
             ****************************************************************************/
             #include "qbarset.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSet
                 \brief Building block for different bar charts
                 QBarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 \mainclass
                 \sa QBarSeries, QGroupedBarSeries, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \qmlclass BarSet QBarSet
                 BarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 \sa BarSeries, GroupedBarSeries, StackedBarSeries, PercentBarSeries
             */
             /*!
                 \property QBarSet::label
                 Defines the label of the barSet.
             */
             /*!
                 \qmlproperty string BarSet::label
                 Defines the label of the barSet.
             */
             /*!
                 \property QBarSet::pen
                 \brief Defines the pen used by the barSet.
             */
             /*!
                 \property QBarSet::brush
                 \brief Defines the brush used by the barSet.
             */
             /*!
                 \property QBarSet::labelBrush
                 \brief Defines the brush used by the barSet's label.
             */
             /*!
                 \property QBarSet::labelFont
                 \brief Defines the font used by the barSet's label.
             */
             /*!
                 \qmlproperty Font BarSet::labelFont
                 Defines the font used by the barSet's label.
                 See the \l {Font} {QML Font Element} for detailed documentation.
             */
             /*!
                 \property QBarSet::color
                 The fill (brush) color of the bar set.
             */
             /*!
                 \qmlproperty color BarSet::color
                 The fill (brush) color of the bar set.
             */
             /*!
                 \property QBarSet::borderColor
                 The line (pen) color of the bar set.
             */
             /*!
                 \qmlproperty color BarSet::borderColor
                 The line (pen) color of the bar set.
             */
             /*!
                 \property QBarSet::labelColor
                 The text (label) color of the bar set.
             */
             /*!
                 \qmlproperty color BarSet::labelColor
                 The text (label) color of the bar set.
             */
             /*!
                 \fn void QBarSet::clicked(int index)
                 The signal is emitted if the user clicks with a mouse on top of barset.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \fn void QBarSet::hovered(bool status)
                 The signal is emitted if mouse is hovered on top of barset.
                 Parameter \a status is true, if mouse entered on top of barset, false if mouse left from top of barset.
             */
             /*!
                 \fn void QBarSet::labelChanged()
                 This signal is emitted when the label of the barSet has changed.
                 \sa label
             */
+            /*!
+                \qmlsignal BarSet::onLabelChanged()
+                This signal is emitted when the label of the barSet has changed.
+            */
             /*!
                 \fn void QBarSet::penChanged()
                 This signal is emitted when the pen of the barSet has changed.
                 \sa pen
             */
             /*!
                 \fn void QBarSet::brushChanged()
                 This signal is emitted when the brush of the barSet has changed.
                 \sa brush
             */
             /*!
                 \fn void QBarSet::labelBrushChanged()
                 This signal is emitted when the brush of the barSet's label has changed.
                 \sa labelBrush
             */
             /*!
                 \fn void QBarSet::labelFontChanged()
                 This signal is emitted when the font of the barSet's label has changed.
                 \sa labelBrush
             */
             /*!
                 \fn void QBarSet::colorChanged(QColor)
                 This signal is emitted when the fill (brush) color of the set has changed to \a color.
             */
             /*!
                 \qmlsignal BarSet::onColorChanged(color color)
                 This signal is emitted when the fill (brush) color of the set has changed to \a color.
             */
             /*!
                 \fn void QBarSet::borderColorChanged(QColor)
                 This signal is emitted when the line (pen) color of the set has changed to \a color.
             */
             /*!
                 \qmlsignal BarSet::onBorderColorChanged(color color)
                 This signal is emitted when the line (pen) color of the set has changed to \a color.
             */
             /*!
                 \fn void QBarSet::labelColorChanged(QColor)
                 This signal is emitted when the text (label) color of the set has changed to \a color.
             */
             /*!
                 \qmlsignal BarSet::onLabelColorChanged(color color)
                 This signal is emitted when the text (label) color of the set has changed to \a color.
             */
             /*!
                 \fn void QBarSet::valuesAdded(int index, int count)
                 This signal is emitted when new values have been added to the set.
                 Parameter \a index indicates the position of the first inserted value.
                 Parameter \a count is the number of iserted values.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal BarSet::onValuesAdded(int index, int count)
                 This signal is emitted when new values have been added to the set.
                 Parameter \a index indicates the position of the first inserted value.
                 Parameter \a count is the number of iserted values.
             */
             /*!
                 \fn void QBarSet::valuesRemoved(int index, int count)
                 This signal is emitted values have been removed from the set.
                 Parameter \a index indicates the position of the first removed value.
                 Parameter \a count is the number of removed values.
                 \sa remove()
             */
             /*!
                 \qmlsignal BarSet::onValuesRemoved(int index, int count)
                 This signal is emitted values have been removed from the set.
                 Parameter \a index indicates the position of the first removed value.
                 Parameter \a count is the number of removed values.
             */
             /*!
                 \fn void QBarSet::valueChanged(int index)
                 This signal is emitted values the value in the set has been modified.
                 Parameter \a index indicates the position of the modified value.
                 \sa at()
             */
             /*!
                 \qmlsignal BarSet::onValueChanged(int index)
                 This signal is emitted values the value in the set has been modified.
                 Parameter \a index indicates the position of the modified value.
             */
             /*!
                 \qmlproperty int BarSet::count
                 The count of values on the barset
             */
             /*!
                 \qmlproperty QVariantList BarSet::values
                 The values of the barset. You can set either a list of reals or a list of points as values. If you set a list of
                 reals as values, the values are automatically completed to points by using the index of a value as it's
                 x-coordinate. For example:
                 \code
                     myBarSet1.values = [0, 5, 1, 5];
                     myBarSet2.values = [Qt.point(0, 1), Qt.point(1, 5), Qt.point(2.2, 4.3)];
                 \endcode
             */
             /*!
                 Constructs QBarSet with a label of \a label and with parent of \a parent
             */
             QBarSet::QBarSet(const QString label, QObject *parent)
                 : QObject(parent)
                 ,d_ptr(new QBarSetPrivate(label,this))
             {
             }
             /*!
                 Destroys the barset
             */
             QBarSet::~QBarSet()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
                 Sets new \a label for set.
             */
             void QBarSet::setLabel(const QString label)
             {
                 d_ptr->m_label = label;
                 emit labelChanged();
             }
             /*!
                 Returns label of the set.
             */
             QString QBarSet::label() const
             {
                 return d_ptr->m_label;
             }
             /*!
                 Appends a point to set. Parameter \a value x coordinate defines the
                 position in x-axis and y coordinate defines the height of bar.
                 Depending on presentation (QBarSeries, QGroupedBarSeries, QStackedBarSeries, QPercentBarSeries)
                 the x values are used or ignored.
             */
             void QBarSet::append(const QPointF value)
             {
                 int index = d_ptr->m_values.count();
                 d_ptr->append(value);
                 emit valuesAdded(index, 1);
             }
             /*!
                 Appends a list of \a values to set. Works like append with single point.
                 \sa append()
             */
             void QBarSet::append(const QList<QPointF> &values)
             {
                 int index = d_ptr->m_values.count();
                 d_ptr->append(values);
                 emit valuesAdded(index, values.count());
             }
             /*!
                 Appends new value \a value to the end of set. Internally the value is converted to QPointF,
                 with x coordinate being the index of appended value and y coordinate is the value.
             */
             void QBarSet::append(const qreal value)
             {
                 // Convert to QPointF and use other append(QPointF) method.
                 append(QPointF(d_ptr->m_values.count(), value));
             }
             /*!
                 Appends a list of reals to set. Works like append with single real value. The \a values in list
                 are converted to QPointF, where x coordinate is the index of point and y coordinate is the value.
                 \sa append()
             */
             void QBarSet::append(const QList<qreal> &values)
             {
                 int index = d_ptr->m_values.count();
                 d_ptr->append(values);
                 emit valuesAdded(index, values.count());
             }
             /*!
                 Convinience operator. Same as append, with real \a value.
                 \sa append()
             */
             QBarSet& QBarSet::operator << (const qreal &value)
             {
                 append(value);
                 return *this;
             }
             /*!
                 Convinience operator. Same as append, with QPointF \a value.
                 \sa append()
             */
             QBarSet& QBarSet::operator << (const QPointF &value)
             {
                 append(value);
                 return *this;
             }
             /*!
                 Inserts new \a value on the \a index position.
                 The value that is currently at this postion is moved to postion index + 1
                 \sa remove()
             */
             void QBarSet::insert(const int index, const qreal value)
             {
                 d_ptr->insert(index, value);
                 emit valuesAdded(index,1);
             }
             /*!
                 Inserts new \a value on the \a index position.
                 The value that is currently at this postion is moved to postion index + 1
                 \sa remove()
             */
             void QBarSet::insert(const int index, const QPointF value)
             {
                 d_ptr->insert(index,value);
                 emit valuesAdded(index,1);
             }
             /*!
                 Removes \a count number of values from the set starting at \a index.
                 \sa insert()
             */
             void QBarSet::remove(const int index, const int count)
             {
                 int removedCount = d_ptr->remove(index,count);
                 if (removedCount > 0) {
                     emit valuesRemoved(index,removedCount);
                 }
                 return;
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::replace(const int index, const qreal value)
             {
                 if (index >= 0 && index < d_ptr->m_values.count()) {
                     d_ptr->replace(index,value);
                     emit valueChanged(index);
                 }
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::replace(const int index, const QPointF value)
             {
                 if (index >= 0 && index < d_ptr->m_values.count()) {
                     d_ptr->replace(index,value);
                     emit valueChanged(index);
                 }
             }
             /*!
                 Returns value of set indexed by \a index. Note that all appended values are stored internally as QPointF.
                 The returned QPointF has x coordinate, which is index (if appended with qreal append) or the x value
                 of the QPointF (if appended with QPointF append).
                 If the index is out of bounds QPointF(0, 0.0) is returned.
             */
             QPointF QBarSet::at(const int index) const
             {
                 if (index < 0 || index >= d_ptr->m_values.count()) {
                     return QPointF(index, 0.0);
                 }
                 return d_ptr->m_values.at(index);
             }
             /*!
                 Returns value of set indexed by \a index. ote that all appended values are stored internally as QPointF.
                 The returned QPointF has x coordinate, which is index (if appended with qreal append) or the x value
                 of the QPointF (if appended with QPointF append).
             */
             QPointF QBarSet::operator [](const int index) const
             {
                 return d_ptr->m_values.at(index);
             }
             /*!
                 Returns count of values in set.
             */
             int QBarSet::count() const
             {
                 return d_ptr->m_values.count();
             }
             /*!
                 Returns sum of all values in barset. The sum is sum of y coordinates in the QPointF representation.
             */
             qreal QBarSet::sum() const
             {
                 qreal total(0);
                 for (int i=0; i < d_ptr->m_values.count(); i++) {
                     //total += d_ptr->m_values.at(i);
                     total += d_ptr->m_values.at(i).y();
                 }
                 return total;
             }
             /*!
                 Sets pen for set. Bars of this set are drawn using \a pen
             */
             void QBarSet::setPen(const QPen &pen)
             {
                   if(d_ptr->m_pen!=pen){
                       d_ptr->m_pen = pen;
                       emit d_ptr->updatedBars();
                       emit penChanged();
                   }
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBarSet::pen() const
             {
                 return d_ptr->m_pen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
             void QBarSet::setBrush(const QBrush &brush)
             {
                 if(d_ptr->m_brush!=brush){
                   d_ptr->m_brush = brush;
                   emit d_ptr->updatedBars();
                   emit brushChanged();
                 }
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush() const
             {
                 return d_ptr->m_brush;
             }
             /*!
                 Sets \a brush of the values that are drawn on top of this barset
             */
             void QBarSet::setLabelBrush(const QBrush &brush)
             {
                 if(d_ptr->m_labelBrush!=brush){
                     d_ptr->m_labelBrush = brush;
                     emit d_ptr->updatedBars();
                     emit labelBrushChanged();
                 }
             }
             /*!
                 Returns brush of the values that are drawn on top of this barset
             */
             QBrush QBarSet::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             /*!
                 Sets the \a font for values that are drawn on top of this barset
             */
             void QBarSet::setLabelFont(const QFont &font)
             {
                 if(d_ptr->m_labelFont!=font) {
                     d_ptr->m_labelFont = font;
                     emit d_ptr->updatedBars();
                     emit labelFontChanged();
                 }
             }
             /*!
                 Returns the pen for values that are drawn on top of this barset
             */
             QFont QBarSet::labelFont() const
             {
                 return d_ptr->m_labelFont;
             }
             /*!
                 Returns the color of the brush of barset.
             */
             QColor QBarSet::color()
             {
                 return brush().color();
             }
             /*!
                 Sets the \a color of brush for this barset
             */
             void QBarSet::setColor(QColor color)
             {
                 QBrush b = brush();
                 if (b.color() != color) {
                     b.setColor(color);
                     setBrush(b);
                     emit colorChanged(color);
                 }
             }
             /*!
                 Returns the color of pen of this barset
             */
             QColor QBarSet::borderColor()
             {
                 return pen().color();
             }
             /*!
                 Sets the color of pen for this barset
             */
             void QBarSet::setBorderColor(QColor color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             /*!
                 Returns the color of labels of this barset
             */
             QColor QBarSet::labelColor()
             {
                 return labelBrush().color();
             }
             /*!
                 Sets the color of labels for this barset
             */
             void QBarSet::setLabelColor(QColor color)
             {
                 QBrush b = labelBrush();
                 if (b.color() != color) {
                     b.setColor(color);
                     setLabelBrush(b);
                     emit labelColorChanged(color);
                 }
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSetPrivate::QBarSetPrivate(const QString label, QBarSet *parent) : QObject(parent),
                 q_ptr(parent),
                 m_label(label)
             {
             }
             QBarSetPrivate::~QBarSetPrivate()
             {
             }
             void QBarSetPrivate::append(QPointF value)
             {
                 m_values.append(value);
                 emit restructuredBars();
             }
             void QBarSetPrivate::append(QList<QPointF> values)
             {
                 for (int i=0; i<values.count(); i++) {
                     m_values.append(values.at(i));
                 }
                 emit restructuredBars();
             }
             void QBarSetPrivate::append(QList<qreal> values)
             {
                 int index = m_values.count();
                 for (int i=0; i<values.count(); i++) {
                     m_values.append(QPointF(index,values.at(i)));
                     index++;
                 }
                 emit restructuredBars();
             }
             void QBarSetPrivate::insert(const int index, const qreal value)
             {
                 m_values.insert(index, QPointF(index, value));
                 emit restructuredBars();
             }
             void QBarSetPrivate::insert(const int index, const QPointF value)
             {
                 m_values.insert(index, value);
                 emit restructuredBars();
             }
             int QBarSetPrivate::remove(const int index, const int count)
             {
                 int removeCount = count;
                 if ((index <0) || (m_values.count() == 0)) {
                     // Invalid index or not values in list, remove nothing.
                     return 0;
                 } else if ((index + count) > m_values.count()) {
                     // Trying to remove more items than list has. Limit amount to be removed.
                     removeCount = m_values.count() - index;
                 }
                 int c = 0;
                 while (c < removeCount) {
                     m_values.removeAt(index);
                     c++;
                 }
                 emit restructuredBars();
                 return removeCount;
             }
             void QBarSetPrivate::replace(const int index, const qreal value)
             {
                 m_values.replace(index,QPointF(index,value));
                 emit updatedBars();
             }
             void QBarSetPrivate::replace(const int index, const QPointF value)
             {
                 m_values.replace(index,value);
                 emit updatedBars();
             }
             #include "moc_qbarset.cpp"
             #include "moc_qbarset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.cpp +20 -11

             /****************************************************************************
             **
             ** 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
             */
             /*!
                 \qmlclass PieSeries QPieSeries
                 \inherits AbstractSeries
                 The following QML shows how to create a simple pie chart.
                 \snippet ../demos/qmlchart/qml/qmlchart/View1.qml 1
                 \beginfloatleft
                 \image demos_qmlchart1.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \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
             */
             /*!
                 \qmlproperty real PieSeries::horizontalPosition
                 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
             */
             /*!
                 \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
             */
             /*!
                 \qmlproperty real PieSeries::verticalPosition
                 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
             */
             /*!
                 \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.
             */
             /*!
                 \qmlproperty real PieSeries::size
                 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.
             */
             /*!
                 \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.
             */
             /*!
                 \qmlproperty real PieSeries::startAngle
                 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.
             */
             /*!
                 \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.
             */
             /*!
                 \qmlproperty real PieSeries::endAngle
                 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.
             */
             /*!
                 \property QPieSeries::count
                 Number of slices in the series.
             */
             /*!
                 \qmlproperty int PieSeries::count
                 Number of slices in the series.
             */
             /*!
                 \fn void QPieSeries::countChanged()
                 Emitted when the slice count has changed.
                 \sa count
             */
+            /*!
+                \qmlsignal PieSeries::onCountChanged()
+                Emitted when the slice count has changed.
+            */
             /*!
                 \property QPieSeries::sum
                 Sum of all slices.
                 The series keeps track of the sum of all slices it holds.
             */
             /*!
                 \qmlproperty real PieSeries::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
             */
+            /*!
+                \qmlsignal PieSeries::onSumChanged()
+                Emitted when the sum of all slices has changed. This may happen for example if you add or remove slices, or if you
+                change value of a slice.
+            */
             /*!
                 \fn void QPieSeries::added(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been added to the series.
                 \sa append(), insert()
             */
             /*!
-                \qmlsignal PieSeries::added(PieSlice slice)
+                \qmlsignal PieSeries::onAdded(PieSlice slice)
                 Emitted when \a slice has been added to the series.
             */
             /*!
                 \fn void QPieSeries::removed(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been removed from the series.
                 \sa remove()
             */
             /*!
-                \qmlsignal PieSeries::removed(PieSlice slice)
+                \qmlsignal PieSeries::onRemoved(PieSlice slice)
                 Emitted when \a slice has been removed from the series.
             */
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
+            /*!
+              \qmlsignal PieSeries::onClicked(PieSlice slice)
+              This signal is emitted when a \a slice has been 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()
             */
+            /*!
+                \qmlsignal PieSeries::onHovered(PieSlice 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.
+            */
             /*!
                 \qmlmethod PieSlice PieSeries::at(int index)
                 Returns slice at \a index. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::find(string label)
                 Returns the first slice with \a label. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::append(string label, real value)
                 Adds a new slice with \a label and \a value to the pie.
             */
             /*!
                 \qmlmethod bool PieSeries::remove(PieSlice slice)
                 Removes the \a slice from the pie. Returns true if the removal was successfull, false otherwise.
             */
             /*!
                 \qmlmethod PieSeries::clear()
                 Removes all slices from the pie.
             */
             /*!
                 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 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 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 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 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 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/qpieslice.cpp +10 -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 "qpieslice.h"
             #include "qpieslice_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSlice
                 \brief Defines a slice in pie series.
                 This object defines the properties of a single slice in a QPieSeries.
                 In addition to the obvious value and label properties the user can also control
                 the visual appearance of a slice. By modifying the visual appearance also means that
                 the user is overriding the default appearance set by the theme.
                 Note that if the user has customized slices and theme is changed all customizations will be lost.
                 To enable user interaction with the pie some basic signals are provided about clicking and hovering.
             */
             /*!
                 \qmlclass PieSlice QPieSlice
                 PieSlice defines the properties of a single slice in a PieSeries. The element should be used
                 as a child for a PieSeries. For example:
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 2
                 An alternative (dynamic) method for adding slices to a PieSeries is using PieSeries.append
                 method.
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 4
                 In that case you may want to use PieSeries.at or PieSeries.find to access the properties of
                 an individual PieSlice instance.
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 5
                 \sa PieSeries
             */
             /*!
              \enum QPieSlice::LabelPosition
              This enum describes the position of the slice label.
              \value LabelOutside Label is outside the slice with an arm.
              \value LabelInside Label is centered inside the slice.
              */
             /*!
                 \property QPieSlice::label
                 Label of the slice.
                 \sa labelVisible, labelBrush, labelFont, labelArmLengthFactor
             */
             /*!
                 \qmlproperty string PieSlice::label
                 Label (text) of the slice.
             */
             /*!
                 \fn void QPieSlice::labelChanged()
                 This signal emitted when the slice label has been changed.
                 \sa label
             */
             /*!
-                \qmlsignal PieSlice::labelChanged()
+                \qmlsignal PieSlice::onLabelChanged()
                 This signal emitted when the slice label has been changed.
                 \sa label
             */
             /*!
                 \property QPieSlice::value
                 Value of the slice.
                 Note that if users sets a negative value it is converted to a positive value.
                 \sa percentage(), QPieSeries::sum()
             */
             /*!
                 \qmlproperty real PieSlice::value
                 Value of the slice. Note that if users sets a negative value it is converted to a positive value.
             */
             /*!
                 \fn void QPieSlice::valueChanged()
                 This signal is emitted when the slice value changes.
                 \sa value
             */
             /*!
-                \qmlsignal PieSlice::valueChanged()
+                \qmlsignal PieSlice::onValueChanged()
                 This signal is emitted when the slice value changes.
                 \sa value
             */
             /*!
                 \property QPieSlice::labelVisible
                 Defines the visibility of slice label. By default the label is not visible.
                 \sa label, labelBrush, labelFont, labelArmLengthFactor
             */
             /*!
                 \qmlproperty bool PieSlice::labelVisible
                 Defines the visibility of slice label. By default the label is not visible.
             */
             /*!
                 \fn void QPieSlice::labelVisibleChanged()
                 This signal emitted when visibility of the slice label has changed.
                 \sa labelVisible
             */
             /*!
-                \qmlsignal PieSlice::labelVisibleChanged()
+                \qmlsignal PieSlice::onLabelVisibleChanged()
                 This signal emitted when visibility of the slice label has changed.
                 \sa labelVisible
             */
             /*!
                 \property QPieSlice::exploded
                 If set to true the slice is "exploded" away from the pie.
                 \sa explodeDistanceFactor
             */
             /*!
                 \qmlproperty bool PieSlice::exploded
                 If set to true the slice is "exploded" away from the pie.
                 \sa explodeDistanceFactor
             */
             /*!
                 \property QPieSlice::pen
                 Pen used to draw the slice border.
             */
             /*!
                 \fn void QPieSlice::penChanged()
                 This signal is emitted when the pen of the slice has changed.
                 \sa pen
             */
             /*!
                 \property QPieSlice::borderColor
                 Color used to draw the slice border.
                 This is a convenience property for modifying the slice pen.
                 \sa pen, borderWidth
             */
             /*!
                 \qmlproperty color PieSlice::borderColor
                 Color used to draw the slice border (pen color).
                 \sa borderWidth
             */
             /*!
                 \fn void QPieSlice::borderColorChanged()
                 This signal is emitted when slice border color changes.
                 \sa pen, borderColor
             */
             /*!
-                \qmlsignal PieSlice::borderColorChanged()
+                \qmlsignal PieSlice::onBorderColorChanged()
                 This signal is emitted when slice border color changes.
                 \sa borderColor
             */
             /*!
                 \property QPieSlice::borderWidth
                 Width of the slice border.
                 This is a convenience property for modifying the slice pen.
                 \sa pen, borderColor
             */
             /*!
                 \qmlproperty int PieSlice::borderWidth
                 Width of the slice border.
                 This is a convenience property for modifying the slice pen.
                 \sa borderColor
             */
             /*!
                 \fn void QPieSlice::borderWidthChanged()
                 This signal is emitted when slice border width changes.
                 \sa pen, borderWidth
             */
             /*!
-                \qmlsignal PieSlice::borderWidthChanged()
+                \qmlsignal PieSlice::onBorderWidthChanged()
                 This signal is emitted when slice border width changes.
                 \sa borderWidth
             */
             /*!
                 \property QPieSlice::brush
                 Brush used to draw the slice.
             */
             /*!
                 \fn void QPieSlice::brushChanged()
                 This signal is emitted when the brush of the slice has changed.
                 \sa brush
             */
             /*!
                 \property QPieSlice::color
                 Fill (brush) color of the slice.
                 This is a convenience property for modifying the slice brush.
                 \sa brush
             */
             /*!
                 \qmlproperty color PieSlice::color
                 Fill (brush) color of the slice.
             */
             /*!
                 \fn void QPieSlice::colorChanged()
                 This signal is emitted when slice color changes.
                 \sa brush
             */
             /*!
-                \qmlsignal PieSlice::colorChanged()
+                \qmlsignal PieSlice::onColorChanged()
                 This signal is emitted when slice color changes.
             */
             /*!
                 \property QPieSlice::labelBrush
                 Brush used to draw label and label arm of the slice.
                 \sa label, labelVisible, labelFont, labelArmLengthFactor
             */
             /*!
                 \fn void QPieSlice::labelBrushChanged()
                 This signal is emitted when the label brush of the slice has changed.
                 \sa labelBrush
             */
             /*!
                 \property QPieSlice::labelColor
                 Color used to draw the slice label.
                 This is a convenience property for modifying the slice label brush.
                 \sa labelBrush
             */
             /*!
                 \qmlproperty color PieSlice::labelColor
                 Color used to draw the slice label.
             */
             /*!
                 \fn void QPieSlice::labelColorChanged()
                 This signal is emitted when slice label color changes.
                 \sa labelColor
             */
             /*!
-                \qmlsignal PieSlice::labelColorChanged()
+                \qmlsignal PieSlice::onLabelColorChanged()
                 This signal is emitted when slice label color changes.
                 \sa labelColor
             */
             /*!
                 \property QPieSlice::labelFont
                 Font used for drawing label text.
                 \sa label, labelVisible, labelArmLengthFactor
             */
             /*!
                 \fn void QPieSlice::labelFontChanged()
                 This signal is emitted when the label font of the slice has changed.
                 \sa labelFont
             */
             /*!
                 \qmlproperty Font PieSlice::labelFont
                 Defines the font used for slice label.
                 See the \l {Font} {QML Font Element} for detailed documentation.
                 \sa labelVisible, labelPosition
             */
             /*!
                 \property QPieSlice::labelPosition
                 Position of the slice label.
                 \sa label, labelVisible
             */
             /*!
                 \qmlproperty LabelPosition PieSlice::labelPosition
                 Position of the slice label. One of PieSlice.LabelOutside or PieSlice.LabelInside.
                 \sa labelVisible
             */
             /*!
                 \property QPieSlice::labelArmLengthFactor
                 Defines the length of the label arm.
                 The factor is relative to pie radius. For example:
 .0 means the length is the same as the radius.
 .5 means the length is half of the radius.
                 By default the arm length is 0.15
                 \sa label, labelVisible, labelBrush, labelFont
             */
             /*!
                 \qmlproperty real PieSlice::labelArmLengthFactor
                 Defines the length of the label arm.
                 The factor is relative to pie radius. For example:
 .0 means the length is the same as the radius.
 .5 means the length is half of the radius.
                 By default the arm length is 0.15
                 \sa labelVisible
             */
             /*!
                 \property QPieSlice::explodeDistanceFactor
                 When the slice is exploded this factor defines how far the slice is exploded away from the pie.
                 The factor is relative to pie radius. For example:
 .0 means the distance is the same as the radius.
 .5 means the distance is half of the radius.
                 By default the distance is is 0.15
                 \sa exploded
             */
             /*!
                 \qmlproperty real PieSlice::explodeDistanceFactor
                 When the slice is exploded this factor defines how far the slice is exploded away from the pie.
                 The factor is relative to pie radius. For example:
 .0 means the distance is the same as the radius.
 .5 means the distance is half of the radius.
                 By default the distance is is 0.15
                 \sa exploded
             */
             /*!
                 \property QPieSlice::percentage
                 Percentage of the slice compared to the sum of all slices in the series.
                 The actual value ranges from 0.0 to 1.0.
                 Updated automatically once the slice is added to the series.
                 \sa value, QPieSeries::sum
             */
             /*!
                 \qmlproperty real PieSlice::percentage
                 Percentage of the slice compared to the sum of all slices in the series.
                 The actual value ranges from 0.0 to 1.0.
                 Updated automatically once the slice is added to the series.
             */
             /*!
                 \fn void QPieSlice::percentageChanged()
                 This signal is emitted when the percentage of the slice has changed.
                 \sa percentage
             */
             /*!
-                \qmlsignal void PieSlice::percentageChanged()
+                \qmlsignal void PieSlice::onPercentageChanged()
                 This signal is emitted when the percentage of the slice has changed.
                 \sa percentage
             */
             /*!
                 \property QPieSlice::startAngle
                 Defines the starting angle of this slice in the series it belongs to.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated automatically once the slice is added to the series.
             */
             /*!
                 \qmlproperty real PieSlice::startAngle
                 Defines the starting angle of this slice in the series it belongs to.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated automatically once the slice is added to the series.
             */
             /*!
                 \fn void QPieSlice::startAngleChanged()
                 This signal is emitted when the starting angle f the slice has changed.
                 \sa startAngle
             */
             /*!
-                \qmlsignal PieSlice::startAngleChanged()
+                \qmlsignal PieSlice::onStartAngleChanged()
                 This signal is emitted when the starting angle f the slice has changed.
                 \sa startAngle
             */
             /*!
                 \property QPieSlice::angleSpan
                 Span of the slice in degrees.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated automatically once the slice is added to the series.
             */
             /*!
                 \qmlproperty real PieSlice::angleSpan
                 Span of the slice in degrees.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated automatically once the slice is added to the series.
             */
             /*!
                 \fn void QPieSlice::angleSpanChanged()
                 This signal is emitted when the angle span of the slice has changed.
                 \sa angleSpan
             */
             /*!
-                \qmlsignal PieSlice::angleSpanChanged()
+                \qmlsignal PieSlice::onAngleSpanChanged()
                 This signal is emitted when the angle span of the slice has changed.
                 \sa angleSpan
             */
             /*!
                 \fn void QPieSlice::clicked()
                 This signal is emitted when user has clicked the slice.
                 \sa QPieSeries::clicked()
             */
             /*!
                 \qmlsignal PieSlice::onClicked()
                 This signal is emitted when user has clicked the slice.
             */
             /*!
                 \fn void QPieSlice::hovered(bool state)
                 This signal is emitted when user has hovered over or away from the slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
                 \sa QPieSeries::hovered()
             */
             /*!
                 \qmlsignal PieSlice::onHovered(bool state)
                 This signal is emitted when user has hovered over or away from the slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
             */
             /*!
                 Constructs an empty slice with a \a parent.
                 \sa QPieSeries::append(), QPieSeries::insert()
             */
             QPieSlice::QPieSlice(QObject *parent)
                 :QObject(parent),
                 d_ptr(new QPieSlicePrivate(this))
             {
             }
             /*!
                 Constructs an empty slice with given \a value, \a label and a \a parent.
                 \sa QPieSeries::append(), QPieSeries::insert()
             */
             QPieSlice::QPieSlice(QString label, qreal value, QObject *parent)
                 :QObject(parent),
                 d_ptr(new QPieSlicePrivate(this))
             {
                 setValue(value);
                 setLabel(label);
             }
             /*!
                 Destroys the slice.
                 User should not delete the slice if it has been added to the series.
             */
             QPieSlice::~QPieSlice()
             {
             }
             void QPieSlice::setLabel(QString label)
             {
                 if (d_ptr->m_data.m_labelText != label) {
                     d_ptr->m_data.m_labelText = label;
                     emit labelChanged();
                 }
             }
             QString QPieSlice::label() const
             {
                 return d_ptr->m_data.m_labelText;
             }
             void QPieSlice::setValue(qreal value)
             {
                 value = qAbs(value); // negative values not allowed
                 if (!qFuzzyIsNull(d_ptr->m_data.m_value - value)) {
                     d_ptr->m_data.m_value = value;
                     emit valueChanged();
                 }
             }
             qreal QPieSlice::value() const
             {
                 return d_ptr->m_data.m_value;
             }
             void QPieSlice::setLabelVisible(bool visible)
             {
                 if (d_ptr->m_data.m_isLabelVisible != visible) {
                     d_ptr->m_data.m_isLabelVisible = visible;
                     emit labelVisibleChanged();
                 }
             }
             bool QPieSlice::isLabelVisible() const
             {
                 return d_ptr->m_data.m_isLabelVisible;
             }
             void QPieSlice::setExploded(bool exploded)
             {
                 if (d_ptr->m_data.m_isExploded != exploded) {
                     d_ptr->m_data.m_isExploded = exploded;
                     emit d_ptr->explodedChanged();
                 }
             }
             QPieSlice::LabelPosition QPieSlice::labelPosition()
             {
                 return d_ptr->m_data.m_labelPosition;
             }
             void QPieSlice::setLabelPosition(LabelPosition position)
             {
                 if (d_ptr->m_data.m_labelPosition != position) {
                     d_ptr->m_data.m_labelPosition = position;
                     emit d_ptr->labelPositionChanged();
                 }
             }
             bool QPieSlice::isExploded() const
             {
                 return d_ptr->m_data.m_isExploded;
             }
             void QPieSlice::setPen(const QPen &pen)
             {
                 d_ptr->setPen(pen, false);
             }
             QPen QPieSlice::pen() const
             {
                 return d_ptr->m_data.m_slicePen;
             }
             QColor QPieSlice::borderColor()
             {
                 return pen().color();
             }
             void QPieSlice::setBorderColor(QColor color)
             {
                 QPen p = pen();
                 if (color != p.color()) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             int QPieSlice::borderWidth()
             {
                 return pen().width();
             }
             void QPieSlice::setBorderWidth(int width)
             {
                 QPen p = pen();
                 if (width != p.width()) {
                     p.setWidth(width);
                     setPen(p);
                 }
             }
             void QPieSlice::setBrush(const QBrush &brush)
             {
                 d_ptr->setBrush(brush, false);
             }
             QBrush QPieSlice::brush() const
             {
                 return d_ptr->m_data.m_sliceBrush;
             }
             QColor QPieSlice::color()
             {
                 return brush().color();
             }
             void QPieSlice::setColor(QColor color)
             {
                 QBrush b = brush();
                 if (color != b.color()) {
                     b.setColor(color);
                     setBrush(b);
                 }
             }
             void QPieSlice::setLabelBrush(const QBrush &brush)
             {
                 d_ptr->setLabelBrush(brush, false);
             }
             QBrush QPieSlice::labelBrush() const
             {
                 return d_ptr->m_data.m_labelBrush;
             }
             QColor QPieSlice::labelColor()
             {
                 return labelBrush().color();
             }
             void QPieSlice::setLabelColor(QColor color)
             {
                 QBrush b = labelBrush();
                 if (color != b.color()) {
                     b.setColor(color);
                     setLabelBrush(b);
                 }
             }
             void QPieSlice::setLabelFont(const QFont &font)
             {
                 d_ptr->setLabelFont(font, false);
             }
             QFont QPieSlice::labelFont() const
             {
                 return d_ptr->m_data.m_labelFont;
             }
             void QPieSlice::setLabelArmLengthFactor(qreal factor)
             {
                 if (!qFuzzyIsNull(d_ptr->m_data.m_labelArmLengthFactor - factor)) {
                     d_ptr->m_data.m_labelArmLengthFactor = factor;
                     emit d_ptr->labelArmLengthFactorChanged();
                 }
             }
             qreal QPieSlice::labelArmLengthFactor() const
             {
                 return d_ptr->m_data.m_labelArmLengthFactor;
             }
             void QPieSlice::setExplodeDistanceFactor(qreal factor)
             {
                 if (!qFuzzyIsNull(d_ptr->m_data.m_explodeDistanceFactor - factor)) {
                     d_ptr->m_data.m_explodeDistanceFactor = factor;
                     emit d_ptr->explodeDistanceFactorChanged();
                 }
             }
             qreal QPieSlice::explodeDistanceFactor() const
             {
                 return d_ptr->m_data.m_explodeDistanceFactor;
             }
             qreal QPieSlice::percentage() const
             {
                 return d_ptr->m_data.m_percentage;
             }
             qreal QPieSlice::startAngle() const
             {
                 return d_ptr->m_data.m_startAngle;
             }
             qreal QPieSlice::angleSpan() const
             {
                 return d_ptr->m_data.m_angleSpan;
             }
             /*!
               Returns the series that this slice belongs to.
               \sa QPieSeries::append()
             */
             QPieSeries *QPieSlice::series() const
             {
                 return d_ptr->m_series;
             }
             QPieSlicePrivate::QPieSlicePrivate(QPieSlice *parent)
                 :QObject(parent),
                 q_ptr(parent),
                 m_series(0)
             {
             }
             QPieSlicePrivate::~QPieSlicePrivate()
             {
             }
             QPieSlicePrivate *QPieSlicePrivate::fromSlice(QPieSlice *slice)
             {
                 return slice->d_func();
             }
             void QPieSlicePrivate::setPen(const QPen &pen, bool themed)
             {
                 if (m_data.m_slicePen != pen) {
                     QPen oldPen = m_data.m_slicePen;
                     m_data.m_slicePen = pen;
                     m_data.m_slicePen.setThemed(themed);
                     emit q_ptr->penChanged();
                     if (oldPen.color() != pen.color())
                         emit q_ptr->borderColorChanged();
                     if (oldPen.width() != pen.width())
                         emit q_ptr->borderWidthChanged();
                 }
             }
             void QPieSlicePrivate::setBrush(const QBrush &brush, bool themed)
             {
                 if (m_data.m_sliceBrush != brush) {
                     QBrush oldBrush = m_data.m_sliceBrush;
                     m_data.m_sliceBrush = brush;
                     m_data.m_sliceBrush.setThemed(themed);
                     emit q_ptr->brushChanged();
                     if (oldBrush.color() != brush.color())
                         emit q_ptr->colorChanged();
                 }
             }
             void QPieSlicePrivate::setLabelBrush(const QBrush &brush, bool themed)
             {
                 if (m_data.m_labelBrush != brush) {
                     QBrush oldBrush = m_data.m_labelBrush;
                     m_data.m_labelBrush = brush;
                     m_data.m_labelBrush.setThemed(themed);
                     emit q_ptr->labelBrushChanged();
                     if (oldBrush.color() != brush.color())
                         emit q_ptr->labelColorChanged();
                 }
             }
             void QPieSlicePrivate::setLabelFont(const QFont &font, bool themed)
             {
                 if (m_data.m_labelFont != font) {
                     m_data.m_labelFont = font;
                     m_data.m_labelFont.setThemed(themed);
                     emit q_ptr->labelFontChanged();
                 }
             }
             void QPieSlicePrivate::setPercentage(qreal percentage)
             {
                 if (!qFuzzyIsNull(m_data.m_percentage - percentage)) {
                     m_data.m_percentage = percentage;
                     emit q_ptr->percentageChanged();
                 }
             }
             void QPieSlicePrivate::setStartAngle(qreal angle)
             {
                 if (!qFuzzyIsNull(m_data.m_startAngle - angle)) {
                     m_data.m_startAngle = angle;
                     emit q_ptr->startAngleChanged();
                 }
             }
             void QPieSlicePrivate::setAngleSpan(qreal span)
             {
                 if (!qFuzzyIsNull(m_data.m_angleSpan - span)) {
                     m_data.m_angleSpan = span;
                     emit q_ptr->angleSpanChanged();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             #include "moc_qpieslice.cpp"
             #include "moc_qpieslice_p.cpp"

src/xychart/qxyseries.cpp +4 -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 "qxyseries.h"
             #include "qxyseries_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                 \qmlclass XYSeries
                 \inherits AbstractSeries
                 The XYSeries class is a base class for line, spline and scatter series.
                 The class cannot be instantiated directly.
             */
             /*!
                 \property QXYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                 \qmlproperty bool XYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \property QXYSeries::color
                 The color of the series. This is line (pen) color in case of QLineSeries or QSplineSeries and
                 fill (brush) color in case of QScatterSeries or QAreaSeries.
                 \sa QXYSeries::pen(), QXYSeries::brush()
             */
             /*!
                 \qmlproperty color XYSeries::color
                 The color of the series. This is line (pen) color in case of LineSeries or SplineSeries and
                 fill (brush) color in case of ScatterSeries or AreaSeries.
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart.
             */
             /*!
                 \qmlsignal XYSeries::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on chart. For example:
                 \code
                 LineSeries {
                     XyPoint { x: 0; y: 0 }
                     XyPoint { x: 1.1; y: 2.1 }
                     onClicked: console.log("onClicked: " + point.x + ", " + point.y);
                 }
                 \endcode
             */
             /*!
                 \fn void QXYSeries::pointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
                 \sa replace()
             */
             /*!
-                \qmlsignal XYSeries::pointReplaced(int index)
+                \qmlsignal XYSeries::onPointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
                 \sa append(), insert()
             */
             /*!
-                \qmlsignal XYSeries::pointAdded(int index)
+                \qmlsignal XYSeries::onPointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
                 \sa remove()
             */
             /*!
-                \qmlsignal XYSeries::pointRemoved(int index)
+                \qmlsignal XYSeries::onPointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
             */
             /*!
                 \fn void QXYSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
-                \qmlsignal XYSeries::colorChanged(QColor color)
+                \qmlsignal XYSeries::onColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \qmlmethod XYSeries::append(real x, real y)
                 Append point (\a x, \a y) to the series
             */
             /*!
                 \qmlmethod XYSeries::replace(real oldX, real oldY, real newX, real newY)
                 Replaces point (\a oldX, \a oldY) with point (\a newX, \a newY). Does nothing, if point (oldX, oldY) does not
                 exist.
             */
             /*!
                 \qmlmethod XYSeries::remove(real x, real y)
                 Removes point (\a x, \a y) from the series. Does nothing, if point (x, y) does not exist.
             */
             /*!
                 \qmlmethod XYSeries::insert(int index, real x, real y)
                 Inserts point (\a x, \a y) to the \a index. If index is 0 or smaller than 0 the point is prepended to the list of
                 points. If index is the same as or bigger than count, the point is appended to the list of points.
             */
             /*!
                 \qmlmethod QPointF XYSeries::at(int index)
                 Returns point at \a index. Returns (0, 0) if the index is not valid.
             */
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QXYSeries::QXYSeries(QXYSeriesPrivate &d,QObject *parent) : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(qreal x,qreal y)
             {
                 append(QPointF(x,y));
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 d->m_points<<point;
             //    emit d->pointAdded(d->m_points.count()-1);
                 emit pointAdded(d->m_points.count()-1);
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QList<QPointF> &points)
             {
                 foreach(const QPointF& point , points) {
                     append(point);
                 }
             }
             /*!
               Replaces data point \a oldX \a oldY with data point \a newX \a newY.
             */
             void QXYSeries::replace(qreal oldX,qreal oldY,qreal newX,qreal newY)
             {
                 replace(QPointF(oldX,oldY),QPointF(newX,newY));
             }
             /*!
               Replaces \a oldPoint with \a newPoint.
             */
             void QXYSeries::replace(const QPointF &oldPoint,const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(oldPoint);
                 if(index==-1) return;
                 d->m_points[index] = newPoint;
             //    emit d->pointReplaced(index);
                 emit pointReplaced(index);
             }
             /*!
               Removes current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x,qreal y)
             {
                 remove(QPointF(x,y));
             }
             /*!
               Removes current \a point x value.
               Note: point y value is ignored.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if(index==-1) return;
                 d->m_points.remove(index);
             //    emit d->pointRemoved(index);
                 emit pointRemoved(index);
             }
             /*!
                Inserts a \a point in the series at \a index position.
             */
             void QXYSeries::insert(int index, const QPointF &point)
             {
                 Q_D(QXYSeries);
                 d->m_points.insert(index, point);
             //    emit d->pointAdded(index);
                 emit pointAdded(index);
             }
             /*!
                 Removes all points from the series.
             */
             void QXYSeries::clear()
             {
                 Q_D(QXYSeries);
                 for (int i = d->m_points.size() - 1; i >= 0; i--)
                     remove(d->m_points.at(i));
             }
             /*!
                 \internal \a pos
             */
             QList<QPointF> QXYSeries::points() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.toList();
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.count();
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen!=pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen QXYSeries::pen() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QXYSeries);
                 if (d->m_brush!=brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QXYSeries::brush() const
             {
                 Q_D(const QXYSeries);
                 return d->m_brush;
             }
             void QXYSeries::setColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit colorChanged(color);
                 }
             }
             QColor QXYSeries::color() const
             {
                 return pen().color();
             }
             void QXYSeries::setPointsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointsVisible != visible){
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             bool QXYSeries::pointsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointsVisible;
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QPointF &point)
             {
                 append(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QList<QPointF>& points)
             {
                 append(points);
                 return *this;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_pointsVisible(false)
             {
             }
             void QXYSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 Q_Q(QXYSeries);
                 const QList<QPointF>& points = q->points();
                 if(points.isEmpty()){
                     minX=0.0;
                     minY=0.0;
                     maxX=1.0;
                     maxY=1.0;
                 }
                 for (int i = 0; i < points.count(); i++)
                 {
                     qreal x = points[i].x();
                     qreal y = points[i].y();
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             QList<LegendMarker*> QXYSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<LegendMarker*> list;
                 return list << new XYLegendMarker(q,legend);
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages