HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2520:73d53b3b614a

Fix some documentation issues...

Miikka Heikkinen -

r2520:73d53b3b614a

parent child

Context file:

r2520:73d53b3b614a

Expand all files

src/areachart/qareaseries.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "abstractdomain_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "qvalueaxis.h"
             #include "qarealegendmarker.h"
             #include "qchart_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 constructed without 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 constructed without 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.
             */
             /*!
                 \qmlproperty real AreaSeries::borderWidth
                 The width of the border line. By default the width is 2.0.
             */
             /*!
                \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::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::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::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on area chart.
             */
             /*!
                 \fn void QAreaSeries::hovered(const QPointF &point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \qmlsignal AreaSeries::onHovered(point point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \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::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()
             {
                 Q_D(QAreaSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
-                Returns QChartSeries::SeriesTypeArea.
+                Returns QAbstractSeries::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);
                 if (d->m_upperSeries != series)
                 	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);
                 if (d->m_pen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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) {
                     bool emitColorChanged = brush.color() != d->m_brush.color();
                     d->m_brush = brush;
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(brush.color());
                 }
             }
             QBrush QAreaSeries::brush() const
             {
                 Q_D(const QAreaSeries);
                 if (d->m_brush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d->m_brush;
             }
             void QAreaSeries::setColor(const QColor &color)
             {
                 QBrush b = brush();
                 if (b == QBrush())
                     b.setStyle(Qt::SolidPattern);
                 b.setColor(color);
                 setBrush(b);
             }
             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_brush(QChartPrivate::defaultBrush()),
                   m_pen(QChartPrivate::defaultPen()),
                   m_upperSeries(upperSeries),
                   m_lowerSeries(lowerSeries),
                   m_pointsVisible(false)
             {
             }
             void QAreaSeriesPrivate::initializeDomain()
             {
                 Q_Q(QAreaSeries);
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 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);
             }
             void QAreaSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem *area = new AreaChartItem(q,parent);
                 m_item.reset(area);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             void  QAreaSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem *area = static_cast<AreaChartItem *>(m_item.data());
                 if (options.testFlag(QChart::SeriesAnimations)) {
                     area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem()));
                     if (q->lowerSeries())
                     area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem()));
                 }else{
                     area->upperLineItem()->setAnimation(0);
                     if (q->lowerSeries())
                            area->lowerLineItem()->setAnimation(0);
                 }
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             QList<QLegendMarker*> QAreaSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QAreaSeries);
                 QList<QLegendMarker*> list;
                 return list << new QAreaLegendMarker(q,legend);
             }
             void QAreaSeriesPrivate::initializeAxes()
             {
             }
             QAbstractAxis::AxisType QAreaSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValue;
             }
             QAbstractAxis* QAreaSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return 0;
             }
             void QAreaSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 Q_Q(QAreaSeries);
                 const QList<QGradient> gradients = theme->seriesGradients();
                 const QList<QColor> colors = theme->seriesColors();
                 if (forced || QChartPrivate::defaultPen() == m_pen) {
                     QPen pen;
                     pen.setColor(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0));
                     pen.setWidthF(2);
                     q->setPen(pen);
                 }
                 if (forced || QChartPrivate::defaultBrush() == m_brush) {
                     QBrush brush(colors.at(index % colors.size()));
                     q->setBrush(brush);
                 }
             }
             #include "moc_qareaseries.cpp"
             #include "moc_qareaseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/datetimeaxis/qdatetimeaxis.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qdatetimeaxis.h"
             #include "qdatetimeaxis_p.h"
             #include "chartdatetimeaxisx_p.h"
             #include "chartdatetimeaxisy_p.h"
             #include "polarchartdatetimeaxisangular_p.h"
             #include "polarchartdatetimeaxisradial_p.h"
             #include "abstractdomain_p.h"
             #include "qchart.h"
             #include <float.h>
             #include <cmath>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QDateTimeAxis
                 \brief The QDateTimeAxis class is used for manipulating chart's axis.
                 \mainclass
                 The labels can be configured by setting an appropriate DateTime format.
                 QDateTimeAxis works correctly with dates from 4714 BCE to 287396 CE.
                 There are also other limitiation related to QDateTime. Please refer to QDateTime documentation.
                 QDateTimeAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Note: QDateTimeAxis is disabled on ARM architecture.
                 \image api_datatime_axis.png
                 QDateTimeAxis can be used with any QXYSeries.
                 To add a data point to the series QDateTime::toMSecsSinceEpoch() is used.
                 \code
                 QLineSeries *series = new QLineSeries;
                 QDateTime xValue;
                 xValue.setDate(QDate(2012, 1 , 18));
                 xValue.setTime(QTime(9, 34));
                 qreal yValue = 12;
                 series->append(xValue.toMSecsSinceEpoch(), yValue);
                 xValue.setDate(QDate(2013, 5 , 11));
                 xValue.setTime(QTime(11, 14));
                 qreal yValue = 22;
                 series->append(xValue.toMSecsSinceEpoch(), yValue);
                 \endcode
                 Adding the series to the chart and setting up the QDateTimeAxis.
                 \code
                 QChartView *chartView = new QChartView;
                 chartView->chart()->addSeries(series);
                 // ...
                 QDateTimeAxis *axisX = new QDateTimeAxis;
                 axisX->setFormat("dd-MM-yyyy h:mm");
                 chartView->chart()->setAxisX(axisX, series);
                 \endcode
             */
             /*!
                 \qmlclass DateTimeAxis QDateTimeAxis
-                \brief The DateTimeAxis element is used for manipulating chart's axes
+                \brief The DateTimeAxis element is used for manipulating chart's axes.
                 \inherits AbstractAxis
                 The labels can be configured by setting an appropriate DateTime format.
                 Note that any date before 4714 BCE or after about 1.4 million CE may not be accurately stored.
                 DateTimeAxis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
               \property QDateTimeAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty real ValuesAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \property QDateTimeAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty real ValuesAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \fn void QDateTimeAxis::minChanged(QDateTime min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \qmlsignal ValuesAxis::onMinChanged(QDateTime min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QDateTimeAxis::maxChanged(QDateTime max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \qmlsignal ValuesAxis::onMaxChanged(QDateTime max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QDateTimeAxis::rangeChanged(QDateTime min, QDateTime max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
               \property QDateTimeAxis::tickCount
               The number of tick marks for the axis.
             */
             /*!
               \qmlproperty int DateTimeAxis::tickCount
               The number of tick marks for the axis.
             */
             /*!
               \property QDateTimeAxis::format
               The format string that is used when creating label for the axis out of a QDateTime object.
               Check QDateTime documentation for information on how the string should be defined.
             */
             /*!
               \qmlproperty string DateTimeAxis::format
               The format string that is used when creating label for the axis out of a QDateTime object.
               Check QDateTime documentation for information on how the string should be defined.
             */
             /*!
               \fn void QDateTimeAxis::tickCountChanged(int tickCount)
               Axis emits signal when \a tickCount number on axis have changed.
             */
             /*!
               \qmlsignal DateTimeAxis::tickCountChanged(int tickCount)
               Axis emits signal when \a tickCount number on axis have changed.
             */
             /*!
               \fn void QDateTimeAxis::formatChanged(QString format)
               Axis emits signal when \a format of the axis has changed.
             */
             /*!
               \qmlsignal DateTimeAxis::onFormatChanged(string format)
               Axis emits signal when \a format of the axis has changed.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QDateTimeAxis::QDateTimeAxis(QObject *parent) :
                 QAbstractAxis(*new QDateTimeAxisPrivate(this), parent)
             {
             }
             /*!
                 \internal
             */
             QDateTimeAxis::QDateTimeAxis(QDateTimeAxisPrivate &d, QObject *parent) : QAbstractAxis(d, parent)
             {
             }
             /*!
                 Destroys the object
             */
             QDateTimeAxis::~QDateTimeAxis()
             {
                 Q_D(QDateTimeAxis);
                 if (d->m_chart)
                     d->m_chart->removeAxis(this);
             }
             void QDateTimeAxis::setMin(QDateTime min)
             {
                 Q_D(QDateTimeAxis);
                 if (min.isValid())
                     d->setRange(min.toMSecsSinceEpoch(), qMax(d->m_max, qreal(min.toMSecsSinceEpoch())));
             }
             QDateTime QDateTimeAxis::min() const
             {
                 Q_D(const QDateTimeAxis);
                 return QDateTime::fromMSecsSinceEpoch(d->m_min);
             }
             void QDateTimeAxis::setMax(QDateTime max)
             {
                 Q_D(QDateTimeAxis);
                 if (max.isValid())
                     d->setRange(qMin(d->m_min, qreal(max.toMSecsSinceEpoch())), max.toMSecsSinceEpoch());
             }
             QDateTime QDateTimeAxis::max() const
             {
                 Q_D(const QDateTimeAxis);
                 return QDateTime::fromMSecsSinceEpoch(d->m_max);
             }
             /*!
               Sets range from \a min to \a max on the axis.
               If min is greater than max then this function returns without making any changes.
             */
             void QDateTimeAxis::setRange(QDateTime min, QDateTime max)
             {
                 Q_D(QDateTimeAxis);
                 if (!min.isValid() || !max.isValid() || min > max)
                     return;
                 d->setRange(min.toMSecsSinceEpoch(),max.toMSecsSinceEpoch());
             }
             void QDateTimeAxis::setFormat(QString format)
             {
                 Q_D(QDateTimeAxis);
                 if (d->m_format != format) {
                     d->m_format = format;
                     emit formatChanged(format);
                 }
             }
             QString QDateTimeAxis::format() const
             {
                 Q_D(const QDateTimeAxis);
                 return d->m_format;
             }
             /*!
               Sets \a count for ticks on the axis.
             */
             void QDateTimeAxis::setTickCount(int count)
             {
                 Q_D(QDateTimeAxis);
                 if (d->m_tickCount != count && count >= 2) {
                     d->m_tickCount = count;
                    emit tickCountChanged(count);
                 }
             }
             /*!
               \fn int QDateTimeAxis::tickCount() const
               Return number of ticks on the axis
             */
             int QDateTimeAxis::tickCount() const
             {
                 Q_D(const QDateTimeAxis);
                 return d->m_tickCount;
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QDateTimeAxis::type() const
             {
                 return AxisTypeDateTime;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QDateTimeAxisPrivate::QDateTimeAxisPrivate(QDateTimeAxis *q)
                 : QAbstractAxisPrivate(q),
                   m_min(0),
                   m_max(0),
                   m_tickCount(5)
             {
                 m_format = "dd-MM-yyyy\nh:mm";
             }
             QDateTimeAxisPrivate::~QDateTimeAxisPrivate()
             {
             }
             void QDateTimeAxisPrivate::setRange(qreal min,qreal max)
             {
                 Q_Q(QDateTimeAxis);
                 bool changed = false;
                 if (m_min != min) {
                     m_min = min;
                     changed = true;
                     emit q->minChanged(QDateTime::fromMSecsSinceEpoch(min));
                 }
                 if (m_max != max) {
                     m_max = max;
                     changed = true;
                     emit q->maxChanged(QDateTime::fromMSecsSinceEpoch(max));
                 }
                 if (changed) {
                     emit q->rangeChanged(QDateTime::fromMSecsSinceEpoch(min), QDateTime::fromMSecsSinceEpoch(max));
                     emit rangeChanged(m_min,m_max);
                 }
             }
             void QDateTimeAxisPrivate::setMin(const QVariant &min)
             {
                 Q_Q(QDateTimeAxis);
                 if (min.canConvert(QVariant::DateTime))
                     q->setMin(min.toDateTime());
             }
             void QDateTimeAxisPrivate::setMax(const QVariant &max)
             {
                 Q_Q(QDateTimeAxis);
                 if (max.canConvert(QVariant::DateTime))
                     q->setMax(max.toDateTime());
             }
             void QDateTimeAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QDateTimeAxis);
                 if (min.canConvert(QVariant::DateTime) && max.canConvert(QVariant::DateTime))
                     q->setRange(min.toDateTime(), max.toDateTime());
             }
             void QDateTimeAxisPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QDateTimeAxis);
                 ChartAxisElement *axis(0);
                 if (m_chart->chartType() == QChart::ChartTypeCartesian) {
                     if (orientation() == Qt::Vertical)
                         axis = new ChartDateTimeAxisY(q,parent);
                     if (orientation() == Qt::Horizontal)
                         axis = new ChartDateTimeAxisX(q,parent);
                 }
                 if (m_chart->chartType() == QChart::ChartTypePolar) {
                     if (orientation() == Qt::Vertical)
                         axis = new PolarChartDateTimeAxisRadial(q, parent);
                     if (orientation() == Qt::Horizontal)
                         axis = new PolarChartDateTimeAxisAngular(q, parent);
                 }
                 m_item.reset(axis);
                 QAbstractAxisPrivate::initializeGraphics(parent);
             }
             void QDateTimeAxisPrivate::initializeDomain(AbstractDomain *domain)
             {
                 if (m_max == m_min) {
                     if (orientation() == Qt::Vertical)
                         setRange(domain->minY(), domain->maxY());
                     else
                         setRange(domain->minX(), domain->maxX());
                 } else {
                     if (orientation() == Qt::Vertical)
                         domain->setRangeY(m_min, m_max);
                     else
                         domain->setRangeX(m_min, m_max);
                 }
             }
             #include "moc_qdatetimeaxis.cpp"
             #include "moc_qdatetimeaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/logvalueaxis/qlogvalueaxis.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qlogvalueaxis.h"
             #include "qlogvalueaxis_p.h"
             #include "chartlogvalueaxisx_p.h"
             #include "chartlogvalueaxisy_p.h"
             #include "polarchartlogvalueaxisangular_p.h"
             #include "polarchartlogvalueaxisradial_p.h"
             #include "abstractdomain_p.h"
             #include <float.h>
             #include <cmath>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLogValueAxis
                 \brief The QLogValueAxis class is used for manipulating chart's axis.
                 \mainclass
                 \note If a QLogValueAxis is attached to a series with one or more points with
                 negative or zero values on the associated dimension, the series will not be
                 plotted at all. This is particularly relevant when XYModelMappers are used,
                 since empty cells in models typically contain zero values.
             */
             /*!
                 \qmlclass LogValueAxis QLogValueAxis
-                \brief The LogValueAxis element is used for manipulating chart's axes
+                \brief The LogValueAxis element is used for manipulating chart's axes.
                 \inherits AbstractAxis
                 \note If a LogValueAxis is attached to a series with one or more points with
                 negative or zero values on the associated dimension, the series will not be
                 plotted at all. This is particularly relevant when XYModelMappers are used,
                 since empty cells in models typically contain zero values.
             */
             /*!
               \property QLogValueAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
               Value has to be greater than 0.
             */
             /*!
               \qmlproperty real LogValueAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
               Value has to be greater than 0.
             */
             /*!
               \property QLogValueAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
               Value has to be greater than 0.
             */
             /*!
               \qmlproperty real LogValueAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
               Value has to be greater than 0.
             */
             /*!
               \property QLogValueAxis::base
               Defines the base of the logarithm.
               Value has to be greater than 0 and not equal 1
             */
             /*!
               \qmlproperty real LogValueAxis::base
               Defines the maximum value on the axis.
               Defines the base of the logarithm.
               Value has to be greater than 0 and not equal 1
             */
             /*!
               \property QLogValueAxis::labelFormat
               Defines the label format of the axis.
               Supported specifiers are: d, i, o, x, X, f, F, e, E, g, G, c
               See QString::sprintf() for additional details.
             */
             /*!
               \qmlproperty real LogValueAxis::labelFormat
               Defines the label format of the axis.
               Supported specifiers are: d, i, o, x, X, f, F, e, E, g, G, c
               See QString::sprintf() for additional details.
             */
             /*!
               \fn void QLogValueAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \qmlsignal LogValueAxis::onMinChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QLogValueAxis::maxChanged(qreal max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \qmlsignal LogValueAxis::onMaxChanged(qreal max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QLogValueAxis::rangeChanged(qreal min, qreal max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
               \fn void QLogValueAxis::labelFormatChanged(const QString &format)
               Axis emits signal when \a format of axis labels has changed.
             */
             /*!
               \qmlsignal LogValueAxis::labelFormatChanged(const QString &format)
                Axis emits signal when \a format of axis labels has changed.
             */
             /*!
               \fn void QLogValueAxis::baseChanged(qreal base)
               Axis emits signal when \a base of logarithm of the axis has changed.
             */
             /*!
               \qmlsignal LogValueAxis::baseChanged(qreal base)
               Axis emits signal when \a base of logarithm of the axis has changed.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QLogValueAxis::QLogValueAxis(QObject *parent) :
                 QAbstractAxis(*new QLogValueAxisPrivate(this), parent)
             {
             }
             /*!
                 \internal
             */
             QLogValueAxis::QLogValueAxis(QLogValueAxisPrivate &d, QObject *parent) : QAbstractAxis(d, parent)
             {
             }
             /*!
                 Destroys the object
             */
             QLogValueAxis::~QLogValueAxis()
             {
                 Q_D(QLogValueAxis);
                 if (d->m_chart)
                     d->m_chart->removeAxis(this);
             }
             void QLogValueAxis::setMin(qreal min)
             {
                 Q_D(QLogValueAxis);
                 setRange(min, qMax(d->m_max, min));
             }
             qreal QLogValueAxis::min() const
             {
                 Q_D(const QLogValueAxis);
                 return d->m_min;
             }
             void QLogValueAxis::setMax(qreal max)
             {
                 Q_D(QLogValueAxis);
                 setRange(qMin(d->m_min, max), max);
             }
             qreal QLogValueAxis::max() const
             {
                 Q_D(const QLogValueAxis);
                 return d->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
               If min is greater than max then this function returns without making any changes.
             */
             void QLogValueAxis::setRange(qreal min, qreal max)
             {
                 Q_D(QLogValueAxis);
                 bool changed = false;
                 if (min > max)
                     return;
                 if (min > 0) {
                     if (!qFuzzyCompare(d->m_min, min)) {
                         d->m_min = min;
                         changed = true;
                         emit minChanged(min);
                     }
                     if (!qFuzzyCompare(d->m_max, max)) {
                         d->m_max = max;
                         changed = true;
                         emit maxChanged(max);
                     }
                     if (changed) {
                         emit rangeChanged(min, max);
                         emit d->rangeChanged(min,max);
                     }
                 }
             }
             void QLogValueAxis::setLabelFormat(const QString &format)
             {
                 Q_D(QLogValueAxis);
                 d->m_format = format;
                 emit labelFormatChanged(format);
             }
             QString QLogValueAxis::labelFormat() const
             {
                 Q_D(const QLogValueAxis);
                 return d->m_format;
             }
             void QLogValueAxis::setBase(qreal base)
             {
                 // check if base is correct
                 if (qFuzzyCompare(base, 1))
                     return;
                 if (base > 0) {
                     Q_D(QLogValueAxis);
                     d->m_base = base;
                     emit baseChanged(base);
                 }
             }
             qreal QLogValueAxis::base() const
             {
                 Q_D(const QLogValueAxis);
                 return d->m_base;
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QLogValueAxis::type() const
             {
                 return AxisTypeLogValue;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLogValueAxisPrivate::QLogValueAxisPrivate(QLogValueAxis *q)
                 : QAbstractAxisPrivate(q),
                   m_min(1),
                   m_max(1),
                   m_base(10),
                   m_format(QString::null)
             {
             }
             QLogValueAxisPrivate::~QLogValueAxisPrivate()
             {
             }
             void QLogValueAxisPrivate::setMin(const QVariant &min)
             {
                 Q_Q(QLogValueAxis);
                 bool ok;
                 qreal value = min.toReal(&ok);
                 if (ok)
                     q->setMin(value);
             }
             void QLogValueAxisPrivate::setMax(const QVariant &max)
             {
                 Q_Q(QLogValueAxis);
                 bool ok;
                 qreal value = max.toReal(&ok);
                 if (ok)
                     q->setMax(value);
             }
             void QLogValueAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QLogValueAxis);
                 bool ok1;
                 bool ok2;
                 qreal value1 = min.toReal(&ok1);
                 qreal value2 = max.toReal(&ok2);
                 if (ok1 && ok2)
                     q->setRange(value1, value2);
             }
             void QLogValueAxisPrivate::setRange(qreal min, qreal max)
             {
                 Q_Q(QLogValueAxis);
                 bool changed = false;
                 if (min > max)
                     return;
                 if (min > 0) {
                     if (!qFuzzyCompare(m_min, min)) {
                         m_min = min;
                         changed = true;
                         emit q->minChanged(min);
                     }
                     if (!qFuzzyCompare(m_max, max)) {
                         m_max = max;
                         changed = true;
                         emit q->maxChanged(max);
                     }
                     if (changed) {
                         emit rangeChanged(min,max);
                         emit q->rangeChanged(min, max);
                     }
                 }
             }
             void QLogValueAxisPrivate::initializeGraphics(QGraphicsItem *parent)
             {
                 Q_Q(QLogValueAxis);
                 ChartAxisElement *axis(0);
                 if (m_chart->chartType() == QChart::ChartTypeCartesian) {
                     if (orientation() == Qt::Vertical)
                         axis = new ChartLogValueAxisY(q,parent);
                     if (orientation() == Qt::Horizontal)
                         axis = new ChartLogValueAxisX(q,parent);
                 }
                 if (m_chart->chartType() == QChart::ChartTypePolar) {
                     if (orientation() == Qt::Vertical)
                         axis = new PolarChartLogValueAxisRadial(q, parent);
                     if (orientation() == Qt::Horizontal)
                         axis = new PolarChartLogValueAxisAngular(q, parent);
                 }
                 m_item.reset(axis);
                 QAbstractAxisPrivate::initializeGraphics(parent);
             }
             void QLogValueAxisPrivate::initializeDomain(AbstractDomain *domain)
             {
                 if (orientation() == Qt::Vertical) {
                     if (!qFuzzyCompare(m_max, m_min)) {
                         domain->setRangeY(m_min, m_max);
                     } else if ( domain->minY() > 0) {
                         setRange(domain->minY(), domain->maxY());
                     } else if (domain->maxY() > 0) {
                         domain->setRangeY(m_min, domain->maxY());
                     } else {
                         domain->setRangeY(1, 10);
                     }
                 }
                 if (orientation() == Qt::Horizontal) {
                     if (!qFuzzyCompare(m_max, m_min)) {
                         domain->setRangeX(m_min, m_max);
                     } else if (domain->minX() > 0){
                         setRange(domain->minX(), domain->maxX());
                     } else if (domain->maxX() > 0) {
                         domain->setRangeX(m_min, domain->maxX());
                     } else {
                         domain->setRangeX(1, 10);
                     }
                 }
             }
             #include "moc_qlogvalueaxis.cpp"
             #include "moc_qlogvalueaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qabstractaxis.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "qchart_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractAxis
                 \brief The QAbstractAxis class is used for manipulating chart's axis.
                 \mainclass
                 Each series can be bound to one or more horizontal and vertical axes, but mixing axis types
                 that would result in different domains is not supported, such as specifying
                 QValueAxis and QLogValueAxis on the same orientation.
                 Properties and visibility of various axis elements such as axis line, title, labels, grid lines,
                 and shades can be individually controlled.
             */
             /*!
                 \qmlclass AbstractAxis QAbstractAxis
-                \brief The AbstractAxis is a base element used for specialized axis elements
+                \brief The AbstractAxis is a base element used for specialized axis elements.
                 Each series can be bound to only one horizontal and vertical axis.
                 Properties and visibility of various axis elements such as axis line, title, labels, grid lines,
                 and shades can be individually controlled.
             */
             /*!
                 \enum QAbstractAxis::AxisType
                 The type of the series object.
                 \value AxisTypeNoAxis
                 \value AxisTypeValue
                 \value AxisTypeBarCategory
                 \value AxisTypeCategory
                 \value AxisTypeDateTime
                 \value AxisTypeLogValue
             */
             /*!
              *\fn void QAbstractAxis::type() const
               Returns the type of the axis
             */
             /*!
               \property QAbstractAxis::lineVisible
               The visibility of the axis line
             */
             /*!
               \qmlproperty bool AbstractAxis::lineVisible
               The visibility of the axis line
             */
             /*!
               \property QAbstractAxis::linePen
               The pen of the line.
             */
             /*!
               \property QAbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \qmlproperty bool AbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \property QAbstractAxis::labelsPen
               The pen of the labels.
             */
             /*!
               \property QAbstractAxis::labelsBrush
               The brush of the labels.
             */
             /*!
               \property QAbstractAxis::visible
               The visibility of the axis.
             */
             /*!
               \qmlproperty bool AbstractAxis::visible
               The visibility of the axis.
             */
             /*!
               \property QAbstractAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \qmlproperty bool AbstractAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \property QAbstractAxis::color
               The color of the axis and ticks.
             */
             /*!
               \qmlproperty color AbstractAxis::color
               The color of the axis and ticks.
             */
             /*!
               \property QAbstractAxis::gridLinePen
               The pen of the grid line.
             */
             /*!
               \property QAbstractAxis::labelsFont
               The font of the axis labels.
             */
             /*!
               \qmlproperty Font AbstractAxis::labelsFont
               The font of the axis labels.
               See the \l {Font} {QML Font Element} for detailed documentation.
             */
             /*!
               \property QAbstractAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \qmlproperty color AbstractAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \property QAbstractAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \qmlproperty int AbstractAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \property QAbstractAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \qmlproperty bool AbstractAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \qmlproperty color AbstractAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \qmlproperty color AbstractAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesPen
               The pen of the axis shades (area between grid lines).
             */
             /*!
               \property QAbstractAxis::shadesBrush
               The brush of the axis shades (area between grid lines).
             */
             /*!
               \property QAbstractAxis::titleVisible
               The visibility of the axis title. By default the value is true.
             */
             /*!
               \qmlproperty bool AbstractAxis::titleVisible
               The visibility of the axis title. By default the value is true.
             */
             /*!
               \property QAbstractAxis::titleText
               The title of the axis. Empty by default.
             */
             /*!
               \qmlproperty String AbstractAxis::titleText
               The title of the axis. Empty by default.
             */
             /*!
               \property QAbstractAxis::titlePen
               The pen of the title text.
             */
             /*!
               \property QAbstractAxis::titleBrush
               The brush of the title text.
             */
             /*!
               \property QAbstractAxis::titleFont
               The font of the title of the axis.
             */
             /*!
               \qmlproperty Font AbstractAxis::titleFont
               The font of the title of the axis.
             */
             /*!
               \property QAbstractAxis::orientation
               The orientation of the axis. Fixed to either Qt::Horizontal or Qt::Vertical when you add the axis to a chart.
             */
             /*!
               \qmlproperty Qt.Orientation AbstractAxis::orientation
               The orientation of the axis. Fixed to either Qt.Horizontal or Qt.Vertical when the axis is set to a series.
             */
             /*!
               \property QAbstractAxis::alignment
               The alignment of the axis. Can be Qt::AlignLeft, Qt::AlignRight, Qt::AlignBottom, or Qt::AlignTop.
             */
             /*!
               \qmlproperty alignment AbstractAxis::alignment
               The alignment of the axis. Can be Qt.AlignLeft, Qt.AlignRight, Qt.AlignBottom, or Qt.AlignTop.
             */
             /*!
               \fn void QAbstractAxis::visibleChanged(bool visible)
               Visibility of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onVisibleChanged(bool visible)
               Visibility of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::linePenChanged(const QPen& pen)
               The pen of the line of the axis has changed to \a pen.
             */
             /*!
               \fn void QAbstractAxis::lineVisibleChanged(bool visible)
               Visibility of the axis line has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onLineVisibleChanged(bool visible)
               Visibility of the axis line has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::labelsVisibleChanged(bool visible)
               Visibility of the labels of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsVisibleChanged(bool visible)
               Visibility of the labels of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::labelsFontChanged(const QFont& font)
               The font of the axis labels has changed to \a font.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsFontChanged(Font font)
               The font of the axis labels has changed to \a font.
             */
             /*!
               \fn void QAbstractAxis::labelsPenChanged(const QPen& pen)
               The pen of the axis labels has changed to \a pen.
             */
             /*!
               \fn void QAbstractAxis::labelsBrushChanged(const QBrush& brush)
               The brush of the axis labels has changed to \a brush.
             */
             /*!
               \fn void QAbstractAxis::labelsAngleChanged(int angle)
               The angle of the axis labels has changed to \a angle.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsAngleChanged(int angle)
               The angle of the axis labels has changed to \a angle.
             */
             /*!
               \fn void QAbstractAxis::gridVisibleChanged(bool visible)
               Visibility of the grid lines of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onGridVisibleChanged(bool visible)
               Visibility of the grid lines of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::gridLinePenChanged(const QPen& pen)
               The pen of the grid line has changed to \a pen.
             */
             /*!
               \fn void QAbstractAxis::colorChanged(QColor color)
               Emitted if the \a color of the axis is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onColorChanged(QColor color)
               Emitted if the \a color of the axis is changed.
             */
             /*!
               \fn void QAbstractAxis::labelsColorChanged(QColor color)
               Emitted if the \a color of the axis labels is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsColorChanged(QColor color)
               Emitted if the \a color of the axis labels is changed.
             */
             /*!
               \fn void QAbstractAxis::titleVisibleChanged(bool visible)
               Visibility of the title text of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onTitleVisibleChanged(bool visible)
               Visibility of the title text of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::titleTextChanged(const QString& text)
               The text of the axis title has changed to \a text.
             */
             /*!
               \qmlsignal AbstractAxis::onTitleTextChanged(String text)
               The text of the axis title has changed to \a text.
             */
             /*!
               \fn void QAbstractAxis::titlePenChanged(const QPen& pen)
               The pen of the axis shades has changed to \a pen.
             */
             /*!
               \fn void QAbstractAxis::titleBrushChanged(const QBrush& brush)
               The brush of the axis title has changed to \a brush.
             */
             /*!
               \fn void QAbstractAxis::titleFontChanged(const QFont& font)
               The font of the axis title has changed to \a font.
             */
             /*!
               \qmlsignal AbstractAxis::onTitleFontChanged(Font font)
               The font of the axis title has changed to \a font.
             */
             /*!
               \fn void QAbstractAxis::shadesVisibleChanged(bool)
               Emitted if the visibility of the axis shades is changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onShadesVisibleChanged(bool visible)
               Emitted if the visibility of the axis shades is changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::shadesColorChanged(QColor color)
               Emitted if the \a color of the axis shades is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onShadesColorChanged(QColor color)
               Emitted if the \a color of the axis shades is changed.
             */
             /*!
               \fn void QAbstractAxis::shadesBorderColorChanged(QColor)
               Emitted if the border \a color of the axis shades is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onBorderColorChanged(QColor color)
               Emitted if the border \a color of the axis shades is changed.
             */
             /*!
               \fn void QAbstractAxis::shadesBrushChanged(const QBrush& brush)
               The brush of the axis shades has changed to \a brush.
             */
             /*!
               \fn void QAbstractAxis::shadesPenChanged(const QPen& pen)
               The pen of the axis shades has changed to \a pen.
             */
             /*!
              \internal
               Constructs new axis object which is a child of \a parent. Ownership is taken by
               QChart when axis added.
             */
             QAbstractAxis::QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent)
                 : QObject(parent),
                   d_ptr(&d)
             {
             }
             /*!
               Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
             QAbstractAxis::~QAbstractAxis()
             {
                 if (d_ptr->m_chart)
                     qFatal("Still binded axis detected !");
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
             void QAbstractAxis::setLinePen(const QPen &pen)
             {
                 if (d_ptr->m_axisPen != pen) {
                     d_ptr->m_axisPen = pen;
                     emit linePenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw axis and ticks.
             */
             QPen QAbstractAxis::linePen() const
             {
                 if (d_ptr->m_axisPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_axisPen;
             }
             //TODO: remove me 2.0
             void QAbstractAxis::setLinePenColor(QColor color)
             {
                 QPen p = d_ptr->m_axisPen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setLinePen(p);
                     emit colorChanged(color);
                 }
             }
             QColor QAbstractAxis::linePenColor() const
             {
                 return linePen().color();
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
             void QAbstractAxis::setLineVisible(bool visible)
             {
                 if (d_ptr->m_arrowVisible != visible) {
                     d_ptr->m_arrowVisible = visible;
                     emit lineVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isLineVisible() const
             {
                 return d_ptr->m_arrowVisible;
             }
             void QAbstractAxis::setGridLineVisible(bool visible)
             {
                 if (d_ptr->m_gridLineVisible != visible) {
                     d_ptr->m_gridLineVisible = visible;
                     emit gridVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isGridLineVisible() const
             {
                 return d_ptr->m_gridLineVisible;
             }
             /*!
               Sets \a pen used to draw grid line.
             */
             void QAbstractAxis::setGridLinePen(const QPen &pen)
             {
                 if (d_ptr->m_gridLinePen != pen) {
                     d_ptr->m_gridLinePen = pen;
                     emit gridLinePenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw grid.
             */
             QPen QAbstractAxis::gridLinePen() const
             {
                 if (d_ptr->m_gridLinePen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_gridLinePen;
             }
             void QAbstractAxis::setLabelsVisible(bool visible)
             {
                 if (d_ptr->m_labelsVisible != visible) {
                     d_ptr->m_labelsVisible = visible;
                     emit labelsVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::labelsVisible() const
             {
                 return d_ptr->m_labelsVisible;
             }
             /*!
               Sets \a pen used to draw labels.
             */
             void QAbstractAxis::setLabelsPen(const QPen &pen)
             {
                 if (d_ptr->m_labelsPen != pen) {
                     d_ptr->m_labelsPen = pen;
                     emit labelsPenChanged(pen);
                 }
             }
             /*!
               Returns the pen used to labels.
             */
             QPen QAbstractAxis::labelsPen() const
             {
                 if (d_ptr->m_labelsPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_labelsPen;
             }
             /*!
               Sets \a brush used to draw labels.
              */
             void QAbstractAxis::setLabelsBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelsBrush != brush) {
                     d_ptr->m_labelsBrush = brush;
                     emit labelsBrushChanged(brush);
                 }
             }
             /*!
               Returns brush used to draw labels.
             */
             QBrush  QAbstractAxis::labelsBrush() const
             {
                 if (d_ptr->m_labelsBrush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d_ptr->m_labelsBrush;
             }
             /*!
               Sets \a font used to draw labels.
             */
             void QAbstractAxis::setLabelsFont(const QFont &font)
             {
                 if (d_ptr->m_labelsFont != font) {
                     d_ptr->m_labelsFont = font;
                     emit labelsFontChanged(font);
                 }
             }
             /*!
               Returns font used to draw labels.
             */
             QFont QAbstractAxis::labelsFont() const
             {
                 if (d_ptr->m_labelsFont == QChartPrivate::defaultFont())
                     return QFont();
                 else
                     return d_ptr->m_labelsFont;
             }
             void QAbstractAxis::setLabelsAngle(int angle)
             {
                 if (d_ptr->m_labelsAngle != angle) {
                     d_ptr->m_labelsAngle = angle;
                     emit labelsAngleChanged(angle);
                 }
             }
             int QAbstractAxis::labelsAngle() const
             {
                 return d_ptr->m_labelsAngle;
             }
             //TODO: remove me 2.0
             void QAbstractAxis::setLabelsColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelsBrush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setLabelsBrush(b);
                     emit labelsColorChanged(color);
                 }
             }
             QColor QAbstractAxis::labelsColor() const
             {
                 return labelsBrush().color();
             }
             void QAbstractAxis::setTitleVisible(bool visible)
             {
                 if (d_ptr->m_titleVisible != visible) {
                     d_ptr->m_titleVisible = visible;
                     emit titleVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isTitleVisible() const
             {
                 return d_ptr->m_titleVisible;
             }
             /*!
               Sets \a pen used to draw title.
             */
             void QAbstractAxis::setTitlePen(const QPen &pen)
             {
                 if (d_ptr->m_titlePen != pen) {
                     d_ptr->m_titlePen = pen;
                     emit titlePenChanged(pen);
                 }
             }
             /*!
               Returns the pen used to title.
             */
             QPen QAbstractAxis::titlePen() const
             {
                 if (d_ptr->m_titlePen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_titlePen;
             }
             /*!
               Sets \a brush used to draw title.
              */
             void QAbstractAxis::setTitleBrush(const QBrush &brush)
             {
                 if (d_ptr->m_titleBrush != brush) {
                     d_ptr->m_titleBrush = brush;
                     emit titleBrushChanged(brush);
                 }
             }
             /*!
               Returns brush used to draw title.
             */
             QBrush QAbstractAxis::titleBrush() const
             {
                 if (d_ptr->m_titleBrush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d_ptr->m_titleBrush;
             }
             /*!
               Sets \a font used to draw title.
             */
             void QAbstractAxis::setTitleFont(const QFont &font)
             {
                 if (d_ptr->m_titleFont != font) {
                     d_ptr->m_titleFont = font;
                     emit titleFontChanged(font);
                 }
             }
             /*!
               Returns font used to draw title.
             */
             QFont QAbstractAxis::titleFont() const
             {
                 if (d_ptr->m_titleFont == QChartPrivate::defaultFont())
                     return QFont();
                 else
                     return d_ptr->m_titleFont;
             }
             void QAbstractAxis::setTitleText(const QString &title)
             {
                 if (d_ptr->m_title != title) {
                     d_ptr->m_title = title;
                     emit titleTextChanged(title);
                 }
             }
             QString QAbstractAxis::titleText() const
             {
                 return d_ptr->m_title;
             }
             void QAbstractAxis::setShadesVisible(bool visible)
             {
                 if (d_ptr->m_shadesVisible != visible) {
                     d_ptr->m_shadesVisible = visible;
                     emit shadesVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::shadesVisible() const
             {
                 return d_ptr->m_shadesVisible;
             }
             /*!
               Sets \a pen used to draw shades.
             */
             void QAbstractAxis::setShadesPen(const QPen &pen)
             {
                 if (d_ptr->m_shadesPen != pen) {
                     d_ptr->m_shadesPen = pen;
                     emit shadesPenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw shades.
             */
             QPen QAbstractAxis::shadesPen() const
             {
                 if (d_ptr->m_shadesPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_shadesPen;
             }
             /*!
               Sets \a brush used to draw shades.
             */
             void QAbstractAxis::setShadesBrush(const QBrush &brush)
             {
                 if (d_ptr->m_shadesBrush != brush) {
                     d_ptr->m_shadesBrush = brush;
                     emit shadesBrushChanged(brush);
                 }
             }
             /*!
                Returns brush used to draw shades.
             */
             QBrush QAbstractAxis::shadesBrush() const
             {
                 if (d_ptr->m_shadesBrush == QChartPrivate::defaultBrush())
                     return QBrush(Qt::SolidPattern);
                 else
                     return d_ptr->m_shadesBrush;
             }
             void QAbstractAxis::setShadesColor(QColor color)
             {
                 QBrush b = d_ptr->m_shadesBrush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setShadesBrush(b);
                     emit shadesColorChanged(color);
                 }
             }
             QColor QAbstractAxis::shadesColor() const
             {
                 return shadesBrush().color();
             }
             void QAbstractAxis::setShadesBorderColor(QColor color)
             {
             	QPen p = d_ptr->m_shadesPen;
             	if (p.color() != color) {
             		p.setColor(color);
             		setShadesPen(p);
             		emit shadesColorChanged(color);
             	}
             }
             QColor QAbstractAxis::shadesBorderColor() const
             {
                 return shadesPen().color();
             }
             bool QAbstractAxis::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAbstractAxis::setVisible(bool visible)
             {
                 if (d_ptr->m_visible != visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged(visible);
                 }
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAbstractAxis::show()
             {
                 setVisible(true);
             }
             /*!
               Sets axis, shades, labels and grid lines to not be visible.
             */
             void QAbstractAxis::hide()
             {
                 setVisible(false);
             }
             /*!
               Sets the minimum value shown on the axis.
               Depending on the actual axis type the \a min parameter is converted to appropriate type.
               If the conversion is impossible then the function call does nothing
             */
             void QAbstractAxis::setMin(const QVariant &min)
             {
                 d_ptr->setMin(min);
             }
             /*!
               Sets the maximum value shown on the axis.
               Depending on the actual axis type the \a max parameter is converted to appropriate type.
               If the conversion is impossible then the function call does nothing
             */
             void QAbstractAxis::setMax(const QVariant &max)
             {
                 d_ptr->setMax(max);
             }
             /*!
               Sets the range shown on the axis.
               Depending on the actual axis type the \a min and \a max parameters are converted to appropriate types.
               If the conversion is impossible then the function call does nothing.
             */
             void QAbstractAxis::setRange(const QVariant &min, const QVariant &max)
             {
                 d_ptr->setRange(min, max);
             }
             /*!
               Returns the orientation in which the axis is being used (Vertical or Horizontal)
             */
             // NOTE: should have const but it breaks BC:
             // http://techbase.kde.org/Policies/Binary_Compatibility_Examples#Change_the_CV-qualifiers_of_a_member_function
             Qt::Orientation QAbstractAxis::orientation()
             {
                 return d_ptr->orientation();
             }
             Qt::Alignment QAbstractAxis::alignment() const
             {
                 return d_ptr->alignment();
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis *q)
                 : q_ptr(q),
                   m_chart(0),
                   m_alignment(0),
                   m_orientation(Qt::Orientation(0)),
                   m_visible(true),
                   m_arrowVisible(true),
                   m_axisPen(QChartPrivate::defaultPen()),
                   m_axisBrush(QChartPrivate::defaultBrush()),
                   m_gridLineVisible(true),
                   m_gridLinePen(QChartPrivate::defaultPen()),
                   m_labelsVisible(true),
                   m_labelsPen(QChartPrivate::defaultPen()),
                   m_labelsBrush(QChartPrivate::defaultBrush()),
                   m_labelsFont(QChartPrivate::defaultFont()),
                   m_labelsAngle(0),
                   m_titleVisible(true),
                   m_titlePen(QChartPrivate::defaultPen()),
                   m_titleBrush(QChartPrivate::defaultBrush()),
                   m_titleFont(QChartPrivate::defaultFont()),
                   m_shadesVisible(false),
                   m_shadesBrush(QChartPrivate::defaultBrush()),
                   m_shadesPen(QChartPrivate::defaultPen()),
                   m_shadesOpacity(1.0),
                   m_dirty(false)
             {
             }
             QAbstractAxisPrivate::~QAbstractAxisPrivate()
             {
             }
             void QAbstractAxisPrivate::setAlignment( Qt::Alignment alignment)
             {
                 switch(alignment) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom:
                     m_orientation = Qt::Horizontal;
                     break;
                     case Qt::AlignLeft:
                     case Qt::AlignRight:
                     m_orientation = Qt::Vertical;
                     break;
                     default:
                     qWarning()<<"No alignment specified !";
                     break;
                 };
                 m_alignment=alignment;
             }
             void QAbstractAxisPrivate::initializeTheme(ChartTheme* theme, bool forced)
             {
                 //TODO: introduce axis brush
                 if (forced || QChartPrivate::defaultPen() == m_axisPen)
                     q_ptr->setLinePen(theme->axisLinePen());
                 if (forced || QChartPrivate::defaultPen() == m_gridLinePen)
                     q_ptr->setGridLinePen(theme->girdLinePen());
                 if (forced || QChartPrivate::defaultBrush() == m_labelsBrush)
                     q_ptr->setLabelsBrush(theme->labelBrush());
                 if (forced || QChartPrivate::defaultPen() == m_labelsPen)
                     q_ptr->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
                 if (forced || QChartPrivate::defaultFont() == m_labelsFont)
                     q_ptr->setLabelsFont(theme->labelFont());
                 if (forced || QChartPrivate::defaultBrush() == m_titleBrush)
                     q_ptr->setTitleBrush(theme->labelBrush());
                 if (forced || QChartPrivate::defaultPen() == m_titlePen)
                     q_ptr->setTitlePen(Qt::NoPen); // NoPen for performance reasons
                 if (forced || QChartPrivate::defaultFont() == m_titleFont) {
                     QFont font(m_labelsFont);
                     font.setBold(true);
                     q_ptr->setTitleFont(font);
                 }
                 if (forced || QChartPrivate::defaultBrush() == m_shadesBrush)
                     q_ptr->setShadesBrush(theme->backgroundShadesBrush());
                 if (forced || QChartPrivate::defaultPen() == m_shadesPen)
                     q_ptr->setShadesPen(theme->backgroundShadesPen());
                 bool axisX = m_orientation == Qt::Horizontal;
                 if (forced && (theme->backgroundShades() == ChartTheme::BackgroundShadesBoth
                         || (theme->backgroundShades() == ChartTheme::BackgroundShadesVertical && axisX)
                         || (theme->backgroundShades() == ChartTheme::BackgroundShadesHorizontal && !axisX))) {
                      q_ptr->setShadesVisible(true);
                 } else if (forced) {
                     q_ptr->setShadesVisible(false);
                 }
             }
             void QAbstractAxisPrivate::handleRangeChanged(qreal min, qreal max)
             {
                 setRange(min,max);
             }
             void QAbstractAxisPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_UNUSED(parent);
             }
             void QAbstractAxisPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 ChartAxisElement *axis = m_item.data();
                 Q_ASSERT(axis);
                 if (options.testFlag(QChart::GridAxisAnimations)) {
                     axis->setAnimation(new AxisAnimation(axis));
                 } else {
                     axis->setAnimation(0);
                 }
             }
             #include "moc_qabstractaxis.cpp"
             #include "moc_qabstractaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/bar/qhorizontalbarseries.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qhorizontalbarseries.h"
             #include "qhorizontalbarseries_p.h"
             #include "horizontalbarchartitem_p.h"
             #include "qbarcategoryaxis.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHorizontalBarSeries
-                \brief Series for creating horizontal bar chart
+                \brief Series for creating horizontal bar chart.
                 \mainclass
                 QHorizontalBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as groups, where bars in same category are grouped next to each other. QHorizontalBarSeries groups the data
                 from sets to categories, which are defined by a QStringList.
                 See the \l {HorizontalBarChart Example} {horizontal bar chart example} to learn how to create a horizontal bar chart.
                 \image examples_horizontalbarchart.png
                 \sa QBarSet, QBarSeries, QPercentBarSeries, QAbstractBarSeries, QStackedBarSeries, QHorizontalStackedBarSeries, QHorizontalPercentBarSeries
             */
             /*!
                 \qmlclass HorizontalBarSeries QHorizontalBarSeries
                 \inherits AbstractBarSeries
                 The following QML shows how to create a simple horizontal bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View9.qml 1
                 \beginfloatleft
                 \image demos_qmlchart9.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QHorizontalBarSeries.
                 QHorizontalBarSeries is QObject which is a child of a \a parent.
             */
             QHorizontalBarSeries::QHorizontalBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QHorizontalBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Destructor.
                 Removes series from chart.
             */
             QHorizontalBarSeries::~QHorizontalBarSeries()
             {
                 Q_D(QHorizontalBarSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
                 Returns QChartSeries::SeriesTypeHorizontalBar.
             */
             QAbstractSeries::SeriesType QHorizontalBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeHorizontalBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QHorizontalBarSeriesPrivate::QHorizontalBarSeriesPrivate(QHorizontalBarSeries *q)
                 : QAbstractBarSeriesPrivate(q)
             {
             }
             void QHorizontalBarSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal y = categoryCount();
                 minX = qMin(minX, min());
                 minY = qMin(minY, - (qreal)0.5);
                 maxX = qMax(maxX, max());
                 maxY = qMax(maxY, y - (qreal)0.5);
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QHorizontalBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QHorizontalBarSeries);
                 HorizontalBarChartItem *bar = new HorizontalBarChartItem(q,parent);
                 m_item.reset(bar);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             #include "moc_qhorizontalbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/percent/qhorizontalpercentbarseries.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qhorizontalpercentbarseries.h"
             #include "qhorizontalpercentbarseries_p.h"
             #include "horizontalpercentbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHorizontalPercentBarSeries
-                \brief Series for creating horizontal percent bar chart
+                \brief Series for creating horizontal percent bar chart.
                 \mainclass
                 QHorizontalPercentBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as groups, where bars in same category are grouped next to each other. QHorizontalPercentBarSeries groups the data
                 from sets to categories, which are defined by a QStringList.
                 See the \l {HorizontalPercentBarChart Example} {horizontal percent bar chart example} to learn how to create a horizontal percent bar chart.
                 \image examples_horizontalpercentbarchart.png
                 \sa QBarSet, QBarSeries, QPercentBarSeries, QAbstractBarSeries, QStackedBarSeries, QHorizontalStackedBarSeries, QHorizontalBarSeries
             */
             /*!
                 \qmlclass HorizontalPercentBarSeries QHorizontalPercentBarSeries
                 \inherits QAbstractBarSeries
                 The following QML shows how to create a simple horizontal percent bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View11.qml 1
                 \beginfloatleft
                 \image demos_qmlchart11.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QHorizontalPercentBarSeries.
                 QHorizontalPercentBarSeries is QObject which is a child of a \a parent.
             */
             QHorizontalPercentBarSeries::QHorizontalPercentBarSeries(QObject *parent) :
                 QAbstractBarSeries(*new QHorizontalPercentBarSeriesPrivate(this), parent)
             {
             }
             /*!
-                Returns QChartSeries::SeriesTypeHorizontalPercentBar.
+                Returns QAbstractSeries::SeriesTypeHorizontalPercentBar.
             */
             QAbstractSeries::SeriesType QHorizontalPercentBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeHorizontalPercentBar;
             }
             /*!
                 Destructor.
                 Removes series from chart.
             */
             QHorizontalPercentBarSeries::~QHorizontalPercentBarSeries()
             {
                 Q_D(QHorizontalPercentBarSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QHorizontalPercentBarSeriesPrivate::QHorizontalPercentBarSeriesPrivate(QHorizontalPercentBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QHorizontalPercentBarSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal y = categoryCount();
                 minX = 0;
                 maxX = 100;
                 minY = qMin(minY, - (qreal)0.5);
                 maxY = qMax(maxY, y - (qreal)0.5);
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QHorizontalPercentBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QHorizontalPercentBarSeries);
                 HorizontalPercentBarChartItem *bar = new HorizontalPercentBarChartItem(q,parent);
                 m_item.reset(bar);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             #include "moc_qhorizontalpercentbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/stacked/qhorizontalstackedbarseries.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qhorizontalstackedbarseries.h"
             #include "qhorizontalstackedbarseries_p.h"
             #include "horizontalstackedbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHorizontalStackedBarSeries
-                \brief Series for creating horizontal stacked bar chart
+                \brief Series for creating horizontal stacked bar chart.
                 \mainclass
                 QHorizontalStackedBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as groups, where bars in same category are grouped next to each other. QHorizontalStackedBarSeries groups the data
                 from sets to categories, which are defined by a QStringList.
                 See the \l {HorizontalStackedBarChart Example} {horizontal stacked bar chart example} to learn how to create a horizontal stacked bar chart.
                 \image examples_horizontalstackedbarchart.png
                 \sa QBarSet, QBarSeries, QPercentBarSeries, QAbstractBarSeries, QStackedBarSeries, QHorizontalPercentBarSeries, QHorizontalBarSeries
             */
             /*!
                 \qmlclass HorizontalStackedBarSeries QHorizontalStackedBarSeries
                 \inherits QAbstractBarSeries
                 The following QML shows how to create a simple horizontal stacked bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View10.qml 1
                 \beginfloatleft
                 \image demos_qmlchart10.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QHorizontalStackedBarSeries.
                 QHorizontalStackedBarSeries is QObject which is a child of a \a parent.
             */
             QHorizontalStackedBarSeries::QHorizontalStackedBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QHorizontalStackedBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Destructor.
                 Removes series from chart.
             */
             QHorizontalStackedBarSeries::~QHorizontalStackedBarSeries()
             {
                 Q_D(QHorizontalStackedBarSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
-                Returns QChartSeries::SeriesTypeHorizontalStackedBar.
+                Returns QAbstractSeries::SeriesTypeHorizontalStackedBar.
             */
             QAbstractSeries::SeriesType QHorizontalStackedBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeHorizontalStackedBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QHorizontalStackedBarSeriesPrivate::QHorizontalStackedBarSeriesPrivate(QHorizontalStackedBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QHorizontalStackedBarSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal y = categoryCount();
                 minX = qMin(minX, bottom());
                 minY = qMin(minY, - (qreal)0.5);
                 maxX = qMax(maxX, top());
                 maxY = qMax(maxY, y - (qreal)0.5);
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QHorizontalStackedBarSeriesPrivate::initializeGraphics(QGraphicsItem *parent)
             {
                 Q_Q(QHorizontalStackedBarSeries);
                 HorizontalStackedBarChartItem *bar = new HorizontalStackedBarChartItem(q,parent);
                 m_item.reset(bar);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             #include "moc_qhorizontalstackedbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qabstractbarseries.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qabstractbarseries.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "abstractdomain_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "qvalueaxis.h"
             #include "qbarcategoryaxis.h"
             #include "qbarlegendmarker.h"
             #include "baranimation_p.h"
             #include "abstractbarchartitem_p.h"
             #include "qchart_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractBarSeries
-                \brief Series for creating a bar chart
+                \brief Series for creating a bar chart.
                 \mainclass
                 QAbstractBarSeries 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 AbstractBarSeries QAbstractBarSeries
                 \inherits QAbstractSeries
                 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
             */
             /*!
                 \qmlproperty AbstractAxis AbstractBarSeries::axisX
                 The x axis used for the series. If you leave both axisX and axisXTop undefined, a BarCategoriesAxis is created for
                 the series.
                 \sa axisXTop
             */
             /*!
                 \qmlproperty AbstractAxis AbstractBarSeries::axisY
                 The y axis used for the series. If you leave both axisY and axisYRight undefined, a ValueAxis is created for
                 the series.
                 \sa axisYRight
             */
             /*!
                 \qmlproperty AbstractAxis AbstractBarSeries::axisXTop
                 The x axis used for the series, drawn on top of the chart view. Note that you can only provide either axisX or
                 axisXTop, but not both.
                 \sa axisX
             */
             /*!
                 \qmlproperty AbstractAxis AbstractBarSeries::axisYRight
                 The y axis used for the series, drawn to the right on the chart view. Note that you can only provide either axisY
                 or axisYRight, but not both.
                 \sa axisY
             */
             /*!
                 \property QAbstractBarSeries::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 QBarSeries this value means the width of one group of bars instead of just one bar.
                 \sa QBarSeries
             */
             /*!
                 \qmlproperty real AbstractBarSeries::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 QBarSeries this value means the width of one group of bars instead of just one bar.
             */
             /*!
                 \property QAbstractBarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \qmlproperty int AbstractBarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \property QAbstractBarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \qmlproperty bool AbstractBarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \fn void QAbstractBarSeries::clicked(int index, QBarSet *barset)
                 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 AbstractBarSeries::onClicked(int index, BarSet barset)
                 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 QAbstractBarSeries::hovered(bool status, QBarSet* barset)
                 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 AbstractBarSeries::onHovered(bool status, BarSet barset)
                 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 QAbstractBarSeries::countChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \qmlsignal AbstractBarSeries::onCountChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \fn void QAbstractBarSeries::labelsVisibleChanged()
                 This signal is emitted when labels visibility have changed.
                 \sa isLabelsVisible(), setLabelsVisible()
             */
             /*!
                 \fn void QAbstractBarSeries::barsetsAdded(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal AbstractBarSeries::onBarsetsAdded(BarSet barset)
                 Emitted when \a barset has been added to the series.
             */
             /*!
                 \fn void QAbstractBarSeries::barsetsRemoved(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been removed from the series.
                 \sa remove()
             */
             /*!
                 \qmlsignal AbstractBarSeries::onBarsetsRemoved(BarSet barset)
                 Emitted when \a barset has been removed from the series.
             */
             /*!
                 \qmlmethod BarSet AbstractBarSeries::at(int index)
                 Returns bar set at \a index. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod BarSet AbstractBarSeries::append(string label, VariantList values)
                 Adds a new bar set with \a label and \a values to \a index. Values is a list of reals.
                 For example:
                 \code
                     myBarSeries.append("set 1", [0, 0.2, 0.2, 0.5, 0.4, 1.5, 0.9]);
                 \endcode
             */
             /*!
                 \qmlmethod BarSet AbstractBarSeries::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 AbstractBarSeries::append()
             */
             /*!
                 \qmlmethod bool AbstractBarSeries::remove(BarSet barset)
                 Removes the barset from the series. Returns true if successful, false otherwise.
             */
             /*!
                 \qmlmethod AbstractBarSeries::clear()
                 Removes all barsets from the series.
             */
             /*!
                 Destructs abstractbarseries and owned barsets.
             */
             QAbstractBarSeries::~QAbstractBarSeries()
             {
             }
             /*!
                 \internal
             */
             QAbstractBarSeries::QAbstractBarSeries(QAbstractBarSeriesPrivate &o, QObject *parent)
                 : QAbstractSeries(o, parent)
             {
                 Q_D(QAbstractSeries);
                 QObject::connect(this, SIGNAL(countChanged()), d, SIGNAL(countChanged()));
             }
             /*!
                 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 QBarSeries \endlink this value means the width of one group of bars instead of just one bar.
             */
             void QAbstractBarSeries::setBarWidth(qreal width)
             {
                 Q_D(QAbstractBarSeries);
                 d->setBarWidth(width);
             }
             /*!
                 Returns the width of the bars of the series.
                 \sa setBarWidth()
             */
             qreal QAbstractBarSeries::barWidth() const
             {
                 Q_D(const QAbstractBarSeries);
                 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 QAbstractBarSeries::append(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->append(set);
                 if (success) {
                     QList<QBarSet *> sets;
                     sets.append(set);
                     set->setParent(this);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes barset from series. Releases ownership of \a set. Deletes the set, if remove
                 was successful.
                 Returns true, if set was removed.
             */
             bool QAbstractBarSeries::remove(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBarSet *> sets;
                     sets.append(set);
                     set->setParent(0);
                     emit barsetsRemoved(sets);
                     emit countChanged();
                     delete set;
                     set = 0;
                 }
                 return success;
             }
             /*!
                 Takes a single \a set from the series. Does not delete the barset object.
                 NOTE: The series remains as the barset's parent object. You must set the
                 parent object to take full ownership.
                 Returns true if take was successful.
             */
             bool QAbstractBarSeries::take(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 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 successfully. 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 QAbstractBarSeries::append(QList<QBarSet *> sets)
             {
                 Q_D(QAbstractBarSeries);
                 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 QAbstractBarSeries::insert(int index, QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->insert(index, set);
                 if (success) {
                     QList<QBarSet *> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes all barsets from the series. Deletes removed sets.
             */
             void QAbstractBarSeries::clear()
             {
                 Q_D(QAbstractBarSeries);
                 QList<QBarSet *> sets = barSets();
                 bool success = d->remove(sets);
                 if (success) {
                     emit barsetsRemoved(sets);
                     emit countChanged();
                     foreach (QBarSet *set, sets)
                         delete set;
                 }
             }
             /*!
                 Returns number of sets in series.
             */
             int QAbstractBarSeries::count() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet *> QAbstractBarSeries::barSets() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_barSets;
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QAbstractBarSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QAbstractBarSeries);
                 if (d->m_labelsVisible != visible) {
                     d->setLabelsVisible(visible);
                     emit labelsVisibleChanged();
                 }
             }
             /*!
                 Returns the visibility of labels
             */
             bool QAbstractBarSeries::isLabelsVisible() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_labelsVisible;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractBarSeriesPrivate::QAbstractBarSeriesPrivate(QAbstractBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barWidth(0.5),  // Default value is 50% of category width
                 m_labelsVisible(false),
                 m_visible(true)
             {
             }
             int QAbstractBarSeriesPrivate::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 QAbstractBarSeriesPrivate::setBarWidth(qreal width)
             {
                 if (width < 0.0)
                     width = 0.0;
                 m_barWidth = width;
                 emit updatedLayout();
             }
             qreal QAbstractBarSeriesPrivate::barWidth() const
             {
                 return m_barWidth;
             }
             QBarSet *QAbstractBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             void QAbstractBarSeriesPrivate::setVisible(bool visible)
             {
                 m_visible = visible;
                 emit visibleChanged();
             }
             void QAbstractBarSeriesPrivate::setLabelsVisible(bool visible)
             {
                 m_labelsVisible = visible;
                 emit labelsVisibleChanged(visible);
             }
             qreal QAbstractBarSeriesPrivate::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);
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QAbstractBarSeriesPrivate::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);
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QAbstractBarSeriesPrivate::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count()))
                     return 0; // No set, no value.
                 else if ((category < 0) || (category >= m_barSets.at(set)->count()))
                     return 0; // No category, no value.
                 return m_barSets.at(set)->at(category);
             }
             qreal QAbstractBarSeriesPrivate::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count()))
                     return 0; // No set, no value.
                 else if ((category < 0) || (category >= m_barSets.at(set)->count()))
                     return 0; // No category, no value.
                 qreal value = m_barSets.at(set)->at(category);
                 qreal sum = categorySum(category);
                 if (qFuzzyCompare(sum, 0))
                     return 0;
                 return value / sum;
             }
             qreal QAbstractBarSeriesPrivate::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);
                 }
                 return sum;
             }
             qreal QAbstractBarSeriesPrivate::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));
                 }
                 return sum;
             }
             qreal QAbstractBarSeriesPrivate::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 QAbstractBarSeriesPrivate::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)->d_ptr.data()->m_values.at(j).x();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QAbstractBarSeriesPrivate::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)->d_ptr.data()->m_values.at(j).x();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QAbstractBarSeriesPrivate::categoryTop(int category)
             {
                 // Returns top (sum of all positive values) of category.
                 // Returns 0, if all values are negative
                 qreal top(0);
                 int count = m_barSets.count();
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count()) {
                         qreal temp = m_barSets.at(set)->at(category);
                         if (temp > 0) {
                             top += temp;
                         }
                     }
                 }
                 return top;
             }
             qreal QAbstractBarSeriesPrivate::categoryBottom(int category)
             {
                 // Returns bottom (sum of all negative values) of category
                 // Returns 0, if all values are positive
                 qreal bottom(0);
                 int count = m_barSets.count();
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count()) {
                         qreal temp = m_barSets.at(set)->at(category);
                         if (temp < 0) {
                             bottom += temp;
                         }
                     }
                 }
                 return bottom;
             }
             qreal QAbstractBarSeriesPrivate::top()
             {
                 // Returns top of all categories
                 qreal top(0);
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal temp = categoryTop(i);
                     if (temp > top)
                         top = temp;
                 }
                 return top;
             }
             qreal QAbstractBarSeriesPrivate::bottom()
             {
                 // Returns bottom of all categories
                 qreal bottom(0);
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal temp = categoryBottom(i);
                     if (temp < bottom)
                         bottom = temp;
                 }
                 return bottom;
             }
             void QAbstractBarSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal seriesMinX = this->minX();
                 qreal seriesMaxX = this->maxX();
                 qreal y = max();
                 minX = qMin(minX, seriesMinX - (qreal)0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, seriesMaxX + (qreal)0.5);
                 maxY = qMax(maxY, y);
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             QList<QLegendMarker*> QAbstractBarSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QAbstractBarSeries);
                 QList<QLegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     QBarLegendMarker* marker = new QBarLegendMarker(q,set,legend);
                     markers << marker;
                 }
                 return markers;
             }
             bool QAbstractBarSeriesPrivate::append(QBarSet *set)
             {
                 if ((m_barSets.contains(set)) || (set == 0))
                     return false; // Fail if set is already in list or set is null.
                 m_barSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 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
                 return true;
             }
             bool QAbstractBarSeriesPrivate::remove(QBarSet *set)
             {
                 if (!m_barSets.contains(set))
                     return false; // Fail if set is not in list
                 m_barSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 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
                 return true;
             }
             bool QAbstractBarSeriesPrivate::append(QList<QBarSet * > sets)
             {
                 foreach (QBarSet *set, sets) {
                     if ((set == 0) || (m_barSets.contains(set)))
                         return false; // Fail if any of the sets is null or is already appended.
                     if (sets.count(set) != 1)
                         return false; // Also fail if same set is more than once in given list.
                 }
                 foreach (QBarSet *set, sets) {
                     m_barSets.append(set);
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                     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
                 return true;
             }
             bool QAbstractBarSeriesPrivate::remove(QList<QBarSet * > sets)
             {
                 if (sets.count() == 0)
                     return false;
                 foreach (QBarSet *set, sets) {
                     if ((set == 0) || (!m_barSets.contains(set)))
                         return false; // Fail if any of the sets is null or is not in series
                     if (sets.count(set) != 1)
                         return false; // Also fail if same set is more than once in given list.
                 }
                 foreach (QBarSet *set, sets) {
                     m_barSets.removeOne(set);
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                     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
                 return true;
             }
             bool QAbstractBarSeriesPrivate::insert(int index, QBarSet *set)
             {
                 if ((m_barSets.contains(set)) || (set == 0))
                     return false; // Fail if set is already in list or set is null.
                 m_barSets.insert(index, set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 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
                 return true;
             }
             void QAbstractBarSeriesPrivate::initializeAxes()
             {
                 Q_Q(QAbstractBarSeries);
                 foreach(QAbstractAxis* axis, m_axes) {
                     if (axis->type() == QAbstractAxis::AxisTypeBarCategory) {
                         switch (q->type()) {
                             case QAbstractSeries::SeriesTypeHorizontalBar:
                             case QAbstractSeries::SeriesTypeHorizontalPercentBar:
                             case QAbstractSeries::SeriesTypeHorizontalStackedBar:
                             if (axis->orientation() == Qt::Vertical)
                             populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
                             break;
                             case QAbstractSeries::SeriesTypeBar:
                             case QAbstractSeries::SeriesTypePercentBar:
                             case QAbstractSeries::SeriesTypeStackedBar:
                             if (axis->orientation() == Qt::Horizontal)
                             populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
                             break;
                             default:
                             qWarning() << "Unexpected series type";
                             break;
                         }
                     }
                 }
             }
             QAbstractAxis::AxisType QAbstractBarSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_Q(const QAbstractBarSeries);
                 switch (q->type()) {
                 case QAbstractSeries::SeriesTypeHorizontalBar:
                 case QAbstractSeries::SeriesTypeHorizontalPercentBar:
                 case QAbstractSeries::SeriesTypeHorizontalStackedBar:
                     if (orientation == Qt::Vertical)
                         return QAbstractAxis::AxisTypeBarCategory;
                     break;
                 case QAbstractSeries::SeriesTypeBar:
                 case QAbstractSeries::SeriesTypePercentBar:
                 case QAbstractSeries::SeriesTypeStackedBar:
                     if (orientation == Qt::Horizontal)
                         return QAbstractAxis::AxisTypeBarCategory;
                     break;
                 default:
                     qWarning() << "Unexpected series type";
                     break;
                 }
                 return QAbstractAxis::AxisTypeValue;
             }
             void QAbstractBarSeriesPrivate::populateCategories(QBarCategoryAxis *axis)
             {
                 QStringList categories;
                 if (axis->categories().isEmpty()) {
                     for (int i(1); i < categoryCount() + 1; i++)
                         categories << QString::number(i);
                     axis->append(categories);
                 }
             }
             QAbstractAxis* QAbstractBarSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return 0;
             }
             void QAbstractBarSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 const QList<QGradient> gradients = theme->seriesGradients();
                 qreal takeAtPos = 0.5;
                 qreal step = 0.2;
                 if (m_barSets.count() > 1) {
                     step = 1.0 / (qreal) m_barSets.count();
                     if (m_barSets.count() % gradients.count())
                     step *= gradients.count();
                     else
                     step *= (gradients.count() - 1);
                 }
                 for (int i(0); i < m_barSets.count(); i++) {
                     int colorIndex = (index + i) % gradients.count();
                     if (i > 0 && i %gradients.count() == 0) {
                         // There is no dedicated base color for each sets, generate more colors
                         takeAtPos += step;
                         if (takeAtPos == 1.0)
                         takeAtPos += step;
                         takeAtPos -= (int) takeAtPos;
                     }
                     if (forced || QChartPrivate::defaultBrush() == m_barSets.at(i)->d_ptr->m_brush)
                         m_barSets.at(i)->setBrush(ChartThemeManager::colorAt(gradients.at(colorIndex), takeAtPos));
                     // Pick label color from the opposite end of the gradient.
                     // 0.3 as a boundary seems to work well.
                     if (forced || QChartPrivate::defaultBrush() == m_barSets.at(i)->d_ptr->m_labelBrush) {
                         if (takeAtPos < 0.3)
                             m_barSets.at(i)->setLabelBrush(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 1));
                         else
                             m_barSets.at(i)->setLabelBrush(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0));
                     }
                     if (forced || QChartPrivate::defaultPen() == m_barSets.at(i)->d_ptr->m_pen) {
                         QColor c = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0);
                         m_barSets.at(i)->setPen(c);
                     }
                 }
             }
             void QAbstractBarSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 AbstractBarChartItem *bar = static_cast<AbstractBarChartItem *>(m_item.data());
                 Q_ASSERT(bar);
                 if (options.testFlag(QChart::SeriesAnimations)) {
                     bar->setAnimation(new BarAnimation(bar));
                 }else{
                     bar->setAnimation(0);
                 }
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qabstractbarseries.cpp"
             #include "moc_qabstractbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.cpp +33 -33

             /****************************************************************************
             **
             ** Copyright (C) 2013 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"
             #include "charthelpers_p.h"
             #include "qchart_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSet
-                \brief Building block for different bar charts
+                \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 QAbstractBarSeries, QBarSeries, 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 AbstractBarSeries, BarSeries, StackedBarSeries, PercentBarSeries
             */
             /*!
                 \property QBarSet::label
-                Defines the label of the barSet.
+                Defines the label of the bar set.
             */
             /*!
                 \qmlproperty string BarSet::label
-                Defines the label of the barSet.
+                Defines the label of the bar set.
             */
             /*!
                 \property QBarSet::pen
-                \brief Defines the pen used by the barSet.
+                \brief Defines the pen used by the bar set.
             */
             /*!
                 \property QBarSet::brush
-                \brief Defines the brush used by the barSet.
+                \brief Defines the brush used by the bar set.
             */
             /*!
                 \property QBarSet::labelBrush
-                \brief Defines the brush used by the barSet's label.
+                \brief Defines the brush used by the bar set's label.
             */
             /*!
                 \property QBarSet::labelFont
-                \brief Defines the font used by the barSet's label.
+                \brief Defines the font used by the bar set's label.
             */
             /*!
                 \qmlproperty Font BarSet::labelFont
-                Defines the font used by the barSet's label.
+                Defines the font used by the bar set'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.
             */
             /*!
                 \qmlproperty real BarSet::borderWidth
                 The width of the border line. By default the width is 2.0.
             */
             /*!
                 \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.
+                The signal is emitted if the user clicks with a mouse on top of bar set.
                 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.
+                The signal is emitted if mouse is hovered on top of bar set.
-                Parameter \a status is true, if mouse entered on top of barset, false if mouse left from top of barset.
+                Parameter \a status is true, if mouse entered on top of bar set, false if mouse left from top of bar set.
             */
             /*!
                 \fn void QBarSet::labelChanged()
-                This signal is emitted when the label of the barSet has changed.
+                This signal is emitted when the label of the bar set has changed.
                 \sa label
             */
             /*!
                 \qmlsignal BarSet::onLabelChanged()
-                This signal is emitted when the label of the barSet has changed.
+                This signal is emitted when the label of the bar set has changed.
             */
             /*!
                 \fn void QBarSet::penChanged()
-                This signal is emitted when the pen of the barSet has changed.
+                This signal is emitted when the pen of the bar set has changed.
                 \sa pen
             */
             /*!
                 \fn void QBarSet::brushChanged()
-                This signal is emitted when the brush of the barSet has changed.
+                This signal is emitted when the brush of the bar set has changed.
                 \sa brush
             */
             /*!
                 \fn void QBarSet::labelBrushChanged()
-                This signal is emitted when the brush of the barSet's label has changed.
+                This signal is emitted when the brush of the bar set's label has changed.
                 \sa labelBrush
             */
             /*!
                 \fn void QBarSet::labelFontChanged()
-                This signal is emitted when the font of the barSet's label has changed.
+                This signal is emitted when the font of the bar set'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 inserted 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 inserted 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
+                The count of values on the bar set
             */
             /*!
                 \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
+                The values of the bar set. 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.
+                Destroys the bar set.
             */
             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 new value \a value to the end of set.
             */
             void QBarSet::append(const qreal value)
             {
                 // Convert to QPointF
                 int index = d_ptr->m_values.count();
                 d_ptr->append(QPointF(d_ptr->m_values.count(), value));
                 emit valuesAdded(index, 1);
             }
             /*!
                 Appends a list of reals to set. Works like append with single real value. The \a values in list
-                are appended to end of barset
+                are appended to end of bar set.
                 \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());
             }
             /*!
                 Convenience operator. Same as append, with real \a value.
                 \sa append()
             */
             QBarSet &QBarSet::operator << (const qreal &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 position index + 1
                 \sa remove()
             */
             void QBarSet::insert(const int index, const qreal 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);
                 }
             }
             /*!
                 Returns value of set indexed by \a index.
                 If the index is out of bounds 0.0 is returned.
             */
             qreal QBarSet::at(const int index) const
             {
                 if (index < 0 || index >= d_ptr->m_values.count())
                     return 0;
                 return d_ptr->m_values.at(index).y();
             }
             /*!
                 Returns value of set indexed by \a index.
                 If the index is out of bounds 0.0 is returned.
             */
             qreal QBarSet::operator [](const int index) const
             {
                 return 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.
+                Returns sum of all values in the bar set.
             */
             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).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
             {
                 if (d_ptr->m_pen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_pen;
             }
             /*!
-                Sets brush for the set. Bars of this set are drawn using \a brush
+                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
             {
                 if (d_ptr->m_brush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d_ptr->m_brush;
             }
             /*!
-                Sets \a brush of the values that are drawn on top of this barset
+                Sets \a brush of the values that are drawn on top of this bar set.
             */
             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
+                Returns brush of the values that are drawn on top of this bar set.
             */
             QBrush QBarSet::labelBrush() const
             {
                 if (d_ptr->m_labelBrush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d_ptr->m_labelBrush;
             }
             /*!
-                Sets the \a font for values that are drawn on top of this barset
+                Sets the \a font for values that are drawn on top of this bar set.
             */
             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
+                Returns the pen for values that are drawn on top of this bar set.
             */
             QFont QBarSet::labelFont() const
             {
                 return d_ptr->m_labelFont;
             }
             /*!
-                Returns the color of the brush of barset.
+                Returns the color of the brush of bar set.
             */
             QColor QBarSet::color()
             {
                 return brush().color();
             }
             /*!
-                Sets the \a color of brush for this barset
+                Sets the \a color of brush for this bar set.
             */
             void QBarSet::setColor(QColor color)
             {
                 QBrush b = brush();
                 if ((b.color() != color) || (b.style() == Qt::NoBrush)) {
                     b.setColor(color);
                     if (b.style() == Qt::NoBrush) {
                         // Set tyle to Qt::SolidPattern. (Default is Qt::NoBrush)
                         // This prevents theme to override color defined in QML side:
                         // BarSet { label: "Bob"; color:"red"; values: [1,2,3] }
                         // The color must be obeyed, since user wanted it.
                         b.setStyle(Qt::SolidPattern);
                     }
                     setBrush(b);
                     emit colorChanged(color);
                 }
             }
             /*!
-                Returns the color of pen of this barset
+                Returns the color of pen of this bar set.
             */
             QColor QBarSet::borderColor()
             {
                 return pen().color();
             }
             /*!
-                Sets the color of pen for this barset
+                Sets the color of pen for this bar set.
             */
             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
+                Returns the color of labels of this bar set.
             */
             QColor QBarSet::labelColor()
             {
                 return labelBrush().color();
             }
             /*!
-                Sets the color of labels for this barset
+                Sets the color of labels for this bar set.
             */
             void QBarSet::setLabelColor(QColor color)
             {
                 QBrush b = labelBrush();
                 if (b == QBrush())
                     b.setStyle(Qt::SolidPattern);
                 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),
                 m_pen(QChartPrivate::defaultPen()),
                 m_brush(QChartPrivate::defaultBrush()),
                 m_labelBrush(QChartPrivate::defaultBrush())
             {
             }
             QBarSetPrivate::~QBarSetPrivate()
             {
             }
             void QBarSetPrivate::append(QPointF value)
             {
                 if (isValidValue(value)) {
                     m_values.append(value);
                     emit restructuredBars();
                 }
             }
             void QBarSetPrivate::append(QList<QPointF> values)
             {
                 for (int i = 0; i < values.count(); i++) {
                     if (isValidValue(values.at(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++) {
                     if (isValidValue(values.at(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))
                     return 0; // Invalid index or not values in list, remove nothing.
                 else if ((index + count) > m_values.count())
                     removeCount = m_values.count() - index; // Trying to remove more items than list has. Limit amount to be removed.
                 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 updatedLayout();
             }
             void QBarSetPrivate::replace(const int index, const QPointF value)
             {
                 m_values.replace(index, value);
                 emit updatedLayout();
             }
             qreal QBarSetPrivate::pos(const int index)
             {
                 if (index < 0 || index >= m_values.count())
                     return 0;
                 return m_values.at(index).x();
             }
             qreal QBarSetPrivate::value(const int index)
             {
                 if (index < 0 || index >= m_values.count())
                     return 0;
                 return m_values.at(index).y();
             }
             #include "moc_qbarset.cpp"
             #include "moc_qbarset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qhbarmodelmapper.cpp +8 -4

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qhbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHBarModelMapper
-                \brief Horizontal model mapper for bar series
+                \brief Horizontal model mapper for bar series.
                 \mainclass
                 Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
                 Horizontal model mapper is used to create a connection between QAbstractBarSeries and QAbstractItemModel derived model object.
                 Model mapper maintains equal size of all the BarSets.
                 Adding/removing value from the BarSet causes the the same change in the rest of the BarSets added to the same series.
                 \note Used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
                 \qmlclass HBarModelMapper QHBarModelMapper
                 HBarModelMapper allows you to use your own QAbstractItemModel derived model with data in rows as a data source
                 for any bar series. It is possible to use both QAbstractItemModel and bar series data API to manipulate data.
                 HBarModelMapper keeps the series and the model in sync.
                 The following QML example would create a bar series with three bar sets (assuming the model has
                 at least four rows). Each bar set would contain data starting from column 1. The name of a set would be defined by
                 the vertical header (of the row).
                 \code
                     BarSeries {
                         HBarModelMapper {
                             model: myCustomModel // QAbstractItemModel derived implementation
                             firstBarSetRow: 1
                             lastBarSetRow: 3
                             firstColumn: 1
                         }
                     }
                 \endcode
             */
             /*!
                 \property QHBarModelMapper::series
                 \brief Defines the QPieSeries object that is used by the mapper.
                 All the data in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \qmlproperty AbstractBarSeries HBarModelMapper::series
                 Defines the AbstractBarSeries based object that is used by the mapper. All the data in the series is discarded when it is
                 set to the mapper. When new series is specified the old series is disconnected (it preserves its data).
             */
             /*!
                 \property QHBarModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \qmlproperty SomeModel HBarModelMapper::model
                 The QAbstractItemModel based model that is used by the mapper. You need to implement the model and expose it to
                 QML as shown in \l {QML Custom Model} demo application. Note: the model has to support adding/removing rows/columns
                 and modifying the data of the cells.
             */
             /*!
                 \property QHBarModelMapper::firstBarSetRow
-                \brief Defines which column of the model is used as the data source for the first bar set
+                \brief Defines which column of the model is used as the data source for the first bar set.
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int HBarModelMapper::firstBarSetRow
                 Defines which column of the model is used as the data source for the first bar set. The default value is -1
                 (invalid mapping).
             */
             /*!
                 \property QHBarModelMapper::lastBarSetRow
-                \brief Defines which column of the model is used as the data source for the last bar set
+                \brief Defines which column of the model is used as the data source for the last bar set.
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int HBarModelMapper::lastBarSetRow
                 Defines which column of the model is used as the data source for the last bar set. The default value is -1
                 (invalid mapping).
             */
             /*!
                 \property QHBarModelMapper::firstColumn
                 \brief Defines which column of the model contains the first values of the QBarSets in the series.
                 Minimal and default value is: 0
             */
             /*!
                 \qmlproperty int HBarModelMapper::firstColumn
                 Defines which column of the model contains the first values of the QBarSets in the series.
                 The default value is 0.
             */
             /*!
                 \property QHBarModelMapper::columnCount
-                \brief Defines the number of columns of the model that are mapped as the data for QAbstractBarSeries
+                \brief Defines the number of columns of the model that are mapped as the data for QAbstractBarSeries.
                 Minimal and default value is: -1 (count limited by the number of columns in the model)
             */
             /*!
                 \qmlproperty int HBarModelMapper::columnCount
                 Defines the number of columns of the model that are mapped as the data for QAbstractBarSeries. The default value is
                 -1 (count limited by the number of columns in the model)
             */
             /*!
                 \fn void QHBarModelMapper::seriesReplaced()
                 Emitted when the series to which mapper is connected to has changed.
             */
             /*!
                 \fn void QHBarModelMapper::modelReplaced()
                 Emitted when the model to which mapper is connected to has changed.
             */
             /*!
                 \fn void QHBarModelMapper::firstBarSetRowChanged()
                 Emitted when the firstBarSetRow has changed.
             */
             /*!
                 \fn void QHBarModelMapper::lastBarSetRowChanged()
                 Emitted when the lastBarSetRow has changed.
             */
             /*!
                 \fn void QHBarModelMapper::firstColumnChanged()
                 Emitted when the firstColumn has changed.
             */
             /*!
                 \fn void QHBarModelMapper::columnCountChanged()
                 Emitted when the columnCount has changed.
             */
             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QHBarModelMapper::QHBarModelMapper(QObject *parent) :
                 QBarModelMapper(parent)
             {
                 QBarModelMapper::setOrientation(Qt::Horizontal);
             }
             QAbstractItemModel *QHBarModelMapper::model() const
             {
                 return QBarModelMapper::model();
             }
             void QHBarModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model != QBarModelMapper::model()) {
                     QBarModelMapper::setModel(model);
                     emit modelReplaced();
                 }
             }
             QAbstractBarSeries *QHBarModelMapper::series() const
             {
                 return QBarModelMapper::series();
             }
             void QHBarModelMapper::setSeries(QAbstractBarSeries *series)
             {
                 if (series != QBarModelMapper::series()) {
                     QBarModelMapper::setSeries(series);
                     emit seriesReplaced();
                 }
             }
             int QHBarModelMapper::firstBarSetRow() const
             {
                 return QBarModelMapper::firstBarSetSection();
             }
             void QHBarModelMapper::setFirstBarSetRow(int firstBarSetRow)
             {
                 if (firstBarSetRow != firstBarSetSection()) {
                     QBarModelMapper::setFirstBarSetSection(firstBarSetRow);
                     emit firstBarSetRowChanged();
                 }
             }
             int QHBarModelMapper::lastBarSetRow() const
             {
                 return QBarModelMapper::lastBarSetSection();
             }
             void QHBarModelMapper::setLastBarSetRow(int lastBarSetRow)
             {
                 if (lastBarSetRow != lastBarSetSection()) {
                     QBarModelMapper::setLastBarSetSection(lastBarSetRow);
                     emit lastBarSetRowChanged();
                 }
             }
             int QHBarModelMapper::firstColumn() const
             {
                 return QBarModelMapper::first();
             }
             void QHBarModelMapper::setFirstColumn(int firstColumn)
             {
                 if (firstColumn != first()) {
                     QBarModelMapper::setFirst(firstColumn);
                     emit firstColumnChanged();
                 }
             }
             int QHBarModelMapper::columnCount() const
             {
                 return QBarModelMapper::count();
             }
             void QHBarModelMapper::setColumnCount(int columnCount)
             {
                 if (columnCount != count()) {
                     QBarModelMapper::setCount(columnCount);
                     emit columnCountChanged();
                 }
             }
             #include "moc_qhbarmodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qvbarmodelmapper.cpp +8 -4

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qvbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QVBarModelMapper
-                \brief Vertical model mapper for bar series
+                \brief Vertical model mapper for bar series.
                 \mainclass
                 Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
                 Vertical model mapper is used to create a connection between QAbstractBarSeries and QAbstractItemModel derived model object.
                 Model mapper maintains equal size of all the BarSets.
                 Adding/removing value from the BarSet causes the the same change in the rest of the BarSets added to the same series.
                 \note Used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
                 \qmlclass VBarModelMapper
                 \mainclass
                 VBarModelMapper allows you to use your own QAbstractItemModel derived model with data in columns as a data source
                 for any bar series. It is possible to use both QAbstractItemModel and bar series data API to manipulate data.
                 VBarModelMapper keeps the series and the model in sync.
                 The following QML example would create a bar series with three bar sets (assuming the
                 model has at least four columns). Each bar set would contain data starting from row 1. The name of a set would be
                 defined by the horizontal header (of the column).
                 \code
                     BarSeries {
                         VBarModelMapper {
                             model: myCustomModel // QAbstractItemModel derived implementation
                             firstBarSetColumn: 1
                             lastBarSetColumn: 3
                             firstRow: 1
                         }
                     }
                 \endcode
             */
             /*!
                 \property QVBarModelMapper::series
                 \brief Defines the QPieSeries object that is used by the mapper.
                 All the data in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \qmlproperty AbstractBarSeries VBarModelMapper::series
                 Defines the AbstractBarSeries based object that is used by the mapper. All the data in the series is discarded when it is
                 set to the mapper. When new series is specified the old series is disconnected (it preserves its data).
             */
             /*!
                 \property QVBarModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \qmlproperty SomeModel VBarModelMapper::model
                 The QAbstractItemModel based model that is used by the mapper. You need to implement the model and expose it to
                 QML as shown in \l {QML Custom Model} demo application. Note: the model has to support adding/removing rows/columns
                 and modifying the data of the cells.
             */
             /*!
                 \property QVBarModelMapper::firstBarSetColumn
-                \brief Defines which column of the model is used as the data source for the first bar set
+                \brief Defines which column of the model is used as the data source for the first bar set.
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int VBarModelMapper::firstBarSetColumn
                 Defines which column of the model is used as the data source for the first bar set. Default value
                 is: -1 (invalid mapping).
             */
             /*!
                 \property QVBarModelMapper::lastBarSetColumn
-                \brief Defines which column of the model is used as the data source for the last bar set
+                \brief Defines which column of the model is used as the data source for the last bar set.
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int VBarModelMapper::lastBarSetColumn
                 Defines which column of the model is used as the data source for the last bar set. Default
                 value is: -1 (invalid mapping).
             */
             /*!
                 \property QVBarModelMapper::firstRow
                 \brief Defines which row of the model contains the first values of the QBarSets in the series.
                 Minimal and default value is: 0
             */
             /*!
                 \qmlproperty int VBarModelMapper::firstRow
                 Defines which row of the model contains the first values of the QBarSets in the series.
                 The default value is 0.
             */
             /*!
                 \property QVBarModelMapper::rowCount
-                \brief Defines the number of rows of the model that are mapped as the data for QAbstractBarSeries
+                \brief Defines the number of rows of the model that are mapped as the data for QAbstractBarSeries.
                 Minimal and default value is: -1 (count limited by the number of rows in the model)
             */
             /*!
                 \qmlproperty int VBarModelMapper::rowCount
                 Defines the number of rows of the model that are mapped as the data for QAbstractBarSeries. The default value is
                 -1 (count limited by the number of rows in the model)
             */
             /*!
                 \fn void QVBarModelMapper::seriesReplaced()
                 Emitted when the series to which mapper is connected to has changed.
             */
             /*!
                 \fn void QVBarModelMapper::modelReplaced()
                 Emitted when the model to which mapper is connected to has changed.
             */
             /*!
                 \fn void QVBarModelMapper::firstBarSetColumnChanged()
                 Emitted when the firstBarSetColumn has changed.
             */
             /*!
                 \fn void QVBarModelMapper::lastBarSetColumnChanged()
                 Emitted when the lastBarSetColumn has changed.
             */
             /*!
                 \fn void QVBarModelMapper::firstRowChanged()
                 Emitted when the firstRow has changed.
             */
             /*!
                 \fn void QVBarModelMapper::rowCountChanged()
                 Emitted when the rowCount has changed.
             */
             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QVBarModelMapper::QVBarModelMapper(QObject *parent) :
                 QBarModelMapper(parent)
             {
                 QBarModelMapper::setOrientation(Qt::Vertical);
             }
             QAbstractItemModel *QVBarModelMapper::model() const
             {
                 return QBarModelMapper::model();
             }
             void QVBarModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model != QBarModelMapper::model()) {
                     QBarModelMapper::setModel(model);
                     emit modelReplaced();
                 }
             }
             QAbstractBarSeries *QVBarModelMapper::series() const
             {
                 return QBarModelMapper::series();
             }
             void QVBarModelMapper::setSeries(QAbstractBarSeries *series)
             {
                 if (series != QBarModelMapper::series()) {
                     QBarModelMapper::setSeries(series);
                     emit seriesReplaced();
                 }
             }
             int QVBarModelMapper::firstBarSetColumn() const
             {
                 return QBarModelMapper::firstBarSetSection();
             }
             void QVBarModelMapper::setFirstBarSetColumn(int firstBarSetColumn)
             {
                 if (firstBarSetColumn != firstBarSetSection()) {
                     QBarModelMapper::setFirstBarSetSection(firstBarSetColumn);
                     emit firstBarSetColumnChanged();
                 }
             }
             int QVBarModelMapper::lastBarSetColumn() const
             {
                 return QBarModelMapper::lastBarSetSection();
             }
             void QVBarModelMapper::setLastBarSetColumn(int lastBarSetColumn)
             {
                 if (lastBarSetColumn != lastBarSetSection()) {
                     QBarModelMapper::setLastBarSetSection(lastBarSetColumn);
                     emit lastBarSetColumnChanged();
                 }
             }
             int QVBarModelMapper::firstRow() const
             {
                 return QBarModelMapper::first();
             }
             void QVBarModelMapper::setFirstRow(int firstRow)
             {
                 if (firstRow != first()) {
                     QBarModelMapper::setFirst(firstRow);
                     emit firstRowChanged();
                 }
             }
             int QVBarModelMapper::rowCount() const
             {
                 return QBarModelMapper::count();
             }
             void QVBarModelMapper::setRowCount(int rowCount)
             {
                 if (rowCount != count()) {
                     QBarModelMapper::setCount(rowCount);
                     emit rowCountChanged();
                 }
             }
             #include "moc_qvbarmodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/bar/qbarseries.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "barchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "qvalueaxis.h"
             #include "qbarcategoryaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
-                \brief Series for creating bar chart
+                \brief Series for creating bar chart.
                 \mainclass
                 QBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as groups, where bars in same category are grouped next to each other. QBarSeries groups the data
                 from sets to categories, which are defined by a QStringList.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a grouped bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QPercentBarSeries, QAbstractBarSeries, QStackedBarSeries
             */
             /*!
                 \qmlclass BarSeries QBarSeries
                 \inherits AbstractBarSeries
                 The following QML shows how to create a simple grouped bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View6.qml 1
                 \beginfloatleft
                 \image demos_qmlchart6.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QBarSeries.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QBarSeriesPrivate(this), parent)
             {
             }
             /*!
-                Returns QChartSeries::SeriesTypeBar.
+                Returns QAbstractSeries::SeriesTypeBar.
             */
             QAbstractSeries::SeriesType QBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBar;
             }
             /*!
                 Destructor. Removes series from chart.
             */
             QBarSeries::~QBarSeries()
             {
                 Q_D(QBarSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QBarSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal x = categoryCount();
                 minX = qMin(minX, - (qreal)0.5);
                 minY = qMin(minY, min());
                 maxX = qMax(maxX, x - (qreal)0.5);
                 maxY = qMax(maxY, max());
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QBarSeries);
                 BarChartItem *bar = new BarChartItem(q,parent);
                 m_item.reset(bar);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             #include "moc_qbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/percent/qpercentbarseries.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qpercentbarseries.h"
             #include "qpercentbarseries_p.h"
             #include "percentbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "qvalueaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPercentBarSeries
-                \brief Series for creating percent bar chart
+                \brief Series for creating percent bar chart.
                 \mainclass
                 QPercentBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as stacks, where each bar is shown as percentage of all bars in that category.
                 QPercentBarSeries groups the data from sets to categories, which are defined by a QStringList.
                 See the \l {PercentbarChart Example} {percent bar chart example} to learn how to create a percent bar chart.
                 \image examples_percentbarchart.png
                 \sa QBarSet, QStackedBarSeries, QAbstractBarSeries
             */
             /*!
                 \qmlclass PercentBarSeries QPercentBarSeries
                 \inherits QAbstractBarSeries
                 The following QML shows how to create a simple percent bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View8.qml 1
                 \beginfloatleft
                 \image demos_qmlchart8.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QPercentBarSeries.
                 QPercentBarSeries is QObject which is a child of a \a parent.
             */
             QPercentBarSeries::QPercentBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QPercentBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Destructor. Removes series from chart.
             */
             QPercentBarSeries::~QPercentBarSeries()
             {
                 Q_D(QPercentBarSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
-                Returns QChartSeries::SeriesTypePercentBar.
+                Returns QAbstractSeries::SeriesTypePercentBar.
             */
             QAbstractSeries::SeriesType QPercentBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePercentBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPercentBarSeriesPrivate::QPercentBarSeriesPrivate(QPercentBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QPercentBarSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal x = categoryCount();
                 minX = qMin(minX, - (qreal)0.5);
                 maxX = qMax(maxX, x - (qreal)0.5);
                 minY = 0;
                 maxY = 100;
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QPercentBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QPercentBarSeries);
                 PercentBarChartItem *bar = new PercentBarChartItem(q,parent);
                 m_item.reset(bar);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             #include "moc_qpercentbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/stacked/qstackedbarseries.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qstackedbarseries.h"
             #include "qstackedbarseries_p.h"
             #include "stackedbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "qvalueaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QStackedBarSeries
-                \brief Series for creating stacked bar chart
+                \brief Series for creating stacked bar chart.
                 \mainclass
                 QStackedBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as stacks, where bars in same category are stacked on top of each other.
                 QStackedBarSeries groups the data from sets to categories, which are defined by QStringList.
                 See the \l {StackedbarChart Example} {stacked bar chart example} to learn how to create a stacked bar chart.
                 \image examples_stackedbarchart.png
                 \sa QBarSet, QPercentBarSeries, QAbstractBarSeries
             */
             /*!
                 \qmlclass StackedBarSeries QStackedBarSeries
                 \inherits AbstractBarSeries
                 The following QML shows how to create a simple stacked bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View7.qml 1
                 \beginfloatleft
                 \image demos_qmlchart7.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QStackedBarSeries.
                 QStackedBarSeries is QObject which is a child of a \a parent.
             */
             QStackedBarSeries::QStackedBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QStackedBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Destructor. Removes series from chart.
             */
             QStackedBarSeries::~QStackedBarSeries()
             {
                 Q_D(QStackedBarSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
-                Returns QChartSeries::SeriesTypeStackedBar.
+                Returns QAbstractSeries::SeriesTypeStackedBar.
             */
             QAbstractSeries::SeriesType QStackedBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeStackedBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QStackedBarSeriesPrivate::QStackedBarSeriesPrivate(QStackedBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QStackedBarSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal x = categoryCount();
                 minX = qMin(minX, - (qreal)0.5);
                 minY = qMin(minY, bottom());
                 maxX = qMax(maxX, x - (qreal)0.5);
                 maxY = qMax(maxY, top());
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QStackedBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QStackedBarSeries);
                 StackedBarChartItem *bar = new StackedBarChartItem(q,parent);
                 m_item.reset(bar);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             #include "moc_qstackedbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qarealegendmarker.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qarealegendmarker.h"
             #include "qarealegendmarker_p.h"
             #include "qareaseries_p.h"
             #include <QAreaSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAreaLegendMarker
-                \brief QAreaLegendMarker object
+                \brief QAreaLegendMarker object.
                 \mainclass
                 QAreaLegendMarker is related to QAreaSeries. One QAreaSeries results in one marker.
                 \sa QLegend QAreaSeries
             */
             /*!
               \fn virtual LegendMarkerType QAreaLegendMarker::type()
               Returns QLegendMarker::LegendMarkerTypeArea
             */
             /*!
               \internal
             */
             QAreaLegendMarker::QAreaLegendMarker(QAreaSeries *series, QLegend *legend, QObject *parent) :
                 QLegendMarker(*new QAreaLegendMarkerPrivate(this,series,legend), parent)
             {
                 d_ptr->updated();
             }
             /*!
               Destructor
             */
             QAreaLegendMarker::~QAreaLegendMarker()
             {
             }
             /*!
                 \internal
             */
             QAreaLegendMarker::QAreaLegendMarker(QAreaLegendMarkerPrivate &d, QObject *parent) :
                 QLegendMarker(d, parent)
             {
             }
             /*!
               Returns related series of marker
             */
             QAreaSeries* QAreaLegendMarker::series()
             {
                 Q_D(QAreaLegendMarker);
                 return d->m_series;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAreaLegendMarkerPrivate::QAreaLegendMarkerPrivate(QAreaLegendMarker *q, QAreaSeries *series, QLegend *legend) :
                 QLegendMarkerPrivate(q,legend),
                 q_ptr(q),
                 m_series(series)
             {
                 QObject::connect(m_series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 QObject::connect(m_series, SIGNAL(nameChanged()), this, SLOT(updated()));
             }
             QAreaLegendMarkerPrivate::~QAreaLegendMarkerPrivate()
             {
             }
             QAreaSeries* QAreaLegendMarkerPrivate::series()
             {
                 return m_series;
             }
             QObject* QAreaLegendMarkerPrivate::relatedObject()
             {
                 return m_series;
             }
             void QAreaLegendMarkerPrivate::updated()
             {
                 bool labelChanged = false;
                 bool brushChanged = false;
                 if (!m_customBrush && (m_item->brush() != m_series->brush())) {
                     m_item->setBrush(m_series->brush());
                     brushChanged = true;
                 }
                 if (!m_customLabel && (m_item->label() != m_series->name())) {
                     m_item->setLabel(m_series->name());
                     labelChanged = true;
                 }
                 invalidateLegend();
                 if (labelChanged)
                     emit q_ptr->labelChanged();
                 if (brushChanged)
                     emit q_ptr->brushChanged();
             }
             #include "moc_qarealegendmarker.cpp"
             #include "moc_qarealegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qbarlegendmarker.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qbarlegendmarker.h"
             #include "qbarlegendmarker_p.h"
             #include <QAbstractBarSeries>
             #include <QBarSet>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarLegendMarker
-                \brief QBarLegendMarker object
+                \brief QBarLegendMarker object.
                 \mainclass
                 QBarLegendMarker is related to QAbstractBarSeries derived classes. With bar series, each marker is related to one QBarSet.
                 \sa QLegend QAbstractBarSeries QBarSet
             */
             /*!
               \fn virtual LegendMarkerType QBarLegendMarker::type()
               Returns QLegendMarker::LegendMarkerTypeBar
             */
             /*!
               \internal
               Constructor
             */
             QBarLegendMarker::QBarLegendMarker(QAbstractBarSeries *series, QBarSet *barset, QLegend *legend, QObject *parent) :
                 QLegendMarker(*new QBarLegendMarkerPrivate(this,series,barset,legend), parent)
             {
                 d_ptr->updated();
             }
             /*!
               Desturctor
             */
             QBarLegendMarker::~QBarLegendMarker()
             {
             }
             /*!
                 \internal
             */
             QBarLegendMarker::QBarLegendMarker(QBarLegendMarkerPrivate &d, QObject *parent) :
                 QLegendMarker(d, parent)
             {
             }
             /*!
               Returns the related series of marker
             */
             QAbstractBarSeries *QBarLegendMarker::series()
             {
                 Q_D(QBarLegendMarker);
                 return d->m_series;
             }
             /*!
               Returns the related barset of marker
             */
             QBarSet* QBarLegendMarker::barset()
             {
                 Q_D(QBarLegendMarker);
                 return d->m_barset;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarLegendMarkerPrivate::QBarLegendMarkerPrivate(QBarLegendMarker *q, QAbstractBarSeries *series, QBarSet *barset, QLegend *legend) :
                 QLegendMarkerPrivate(q,legend),
                 q_ptr(q),
                 m_series(series),
                 m_barset(barset)
             {
                 QObject::connect(m_barset, SIGNAL(penChanged()), this, SLOT(updated()));
                 QObject::connect(m_barset, SIGNAL(labelChanged()), this, SLOT(updated()));
                 QObject::connect(m_barset, SIGNAL(brushChanged()), this, SLOT(updated()));
             }
             QBarLegendMarkerPrivate::~QBarLegendMarkerPrivate()
             {
             }
             QAbstractBarSeries* QBarLegendMarkerPrivate::series()
             {
                 return m_series;
             }
             QObject* QBarLegendMarkerPrivate::relatedObject()
             {
                 return m_barset;
             }
             void QBarLegendMarkerPrivate::updated()
             {
                 bool labelChanged = false;
                 bool brushChanged = false;
                 bool penChanged = false;
                 if (!m_customPen && (m_item->pen() != m_barset->pen())) {
                     m_item->setPen(m_barset->pen());
                     penChanged = true;
                 }
                 if (!m_customBrush && (m_item->brush() != m_barset->brush())) {
                     m_item->setBrush(m_barset->brush());
                     brushChanged = true;
                 }
                 if (!m_customLabel && (m_item->label() != m_barset->label())) {
                     m_item->setLabel(m_barset->label());
                     labelChanged = true;
                 }
                 invalidateLegend();
                 if (labelChanged)
                     emit q_ptr->labelChanged();
                 if (brushChanged)
                     emit q_ptr->brushChanged();
                 if (penChanged)
                     emit q_ptr->penChanged();
             }
             #include "moc_qbarlegendmarker.cpp"
             #include "moc_qbarlegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.cpp +1 -1

             /****************************************************************************
              **
              ** Copyright (C) 2013 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 "qlegend.h"
             #include "qlegend_p.h"
             #include "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "qchart_p.h"
             #include "legendlayout_p.h"
             #include "chartpresenter_p.h"
             #include "abstractchartlayout_p.h"
             #include "qlegendmarker.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
             #include "chartdataset_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QGraphicsItemGroup>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegend
-                \brief Legend object
+                \brief Legend object.
                 \mainclass
                 QLegend is a graphical object for displaying the legend of the chart. Legend state is updated by QChart, when
                 series have been changed. By default, legend is drawn by QChart, but user can set a new parent to legend and
                 handle the drawing manually.
                 User isn't supposed to create or delete legend objects, but can reference it via QChart class.
                 \image examples_percentbarchart_legend.png
                 \sa QChart
             */
             /*!
                 \qmlclass Legend QLegend
                 \brief Legend is part of QtCommercial Chart QML API.
                 Legend is a graphical object, whics displays legend of the chart. Legend state is updated by ChartView, when
                 series have been changed. Legend is used via ChartView class. For example:
                 \code
                     ChartView {
                         legend.visible: true
                         legend.alignment: Qt.AlignBottom
                         // Add a few series...
                     }
                 \endcode
                 \image examples_percentbarchart_legend.png
                 Please note that there is no QML API available for modifying legend markers, unlike in the Qt API of Charts.
                 The use case of modifying markers can be implemented for example by creating your own custom legend. For an example
                 on how to do this, see \l {demos/qmlcustomlegend}{Qml Custom Demo} application.
             */
             /*!
                 \property QLegend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt::AlignTop, Qt::AlignBottom, Qt::AlignLeft, Qt::AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \qmlproperty Qt.Alignment Legend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt.AlignTop, Qt.AlignBottom, Qt.AlignLeft, Qt.AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \property QLegend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \qmlproperty bool Legend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \property QLegend::color
                 The color of the legend, i.e. the background (brush) color. Note that if you change the color
                 of the legend, the style of the legend brush is set to Qt::SolidPattern.
             */
             /*!
                 \qmlproperty color Legend::color
                 The color of the legend, i.e. the background (brush) color.
             */
             /*!
                 \property QLegend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
                 \qmlproperty color Legend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
                 \property QLegend::font
                 The font of markers used by legend
             */
             /*!
                 \qmlproperty Font Legend::font
                 The font of markers used by legend
             */
             /*!
                 \property QLegend::labelColor
                 The color of brush used to draw labels.
             */
             /*!
                 \qmlproperty color QLegend::labelColor
                 The color of brush used to draw labels.
             */
             /*!
                 \fn void QLegend::backgroundVisibleChanged(bool)
                 The visibility of the legend background changed to \a visible.
             */
             /*!
                 \fn void QLegend::colorChanged(QColor)
                 The color of the legend background changed to \a color.
             */
             /*!
                 \fn void QLegend::borderColorChanged(QColor)
                 The border color of the legend background changed to \a color.
             */
             /*!
                 \fn void QLegend::fontChanged(QFont)
                 The font of markers of the legend changed to \a font.
             */
             /*!
                 \fn void QLegend::labelColorChanged(QColor color)
                 This signal is emitted when the color of brush used to draw labels has changed to \a color.
             */
             QLegend::QLegend(QChart *chart): QGraphicsWidget(chart),
                 d_ptr(new QLegendPrivate(chart->d_ptr->m_presenter, chart, this))
             {
                 setZValue(ChartPresenter::LegendZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 QObject::connect(chart->d_ptr->m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), d_ptr.data(), SLOT(handleSeriesAdded(QAbstractSeries*)));
                 QObject::connect(chart->d_ptr->m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), d_ptr.data(), SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 setLayout(d_ptr->m_layout);
             }
             /*!
                 Destroys the legend object. Legend is always owned by a QChart, so an application should never call this.
             */
             QLegend::~QLegend()
             {
             }
             /*!
              \internal
              */
             void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 if (!d_ptr->m_backgroundVisible)
                     return;
                 painter->setOpacity(opacity());
                 painter->setPen(d_ptr->m_pen);
                 painter->setBrush(d_ptr->m_brush);
                 painter->drawRoundRect(rect(), d_ptr->roundness(rect().width()), d_ptr->roundness(rect().height()));
             }
             /*!
              Sets the \a brush of legend. Brush affects the background of legend.
              */
             void QLegend::setBrush(const QBrush &brush)
             {
                 if (d_ptr->m_brush != brush) {
                     d_ptr->m_brush = brush;
                     update();
                     emit colorChanged(brush.color());
                 }
             }
             /*!
              Returns the brush used by legend.
              */
             QBrush QLegend::brush() const
             {
                 return d_ptr->m_brush;
             }
             void QLegend::setColor(QColor color)
             {
                 QBrush b = d_ptr->m_brush;
                 if (b.style() != Qt::SolidPattern || b.color() != color) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     setBrush(b);
                 }
             }
             QColor QLegend::color()
             {
                 return d_ptr->m_brush.color();
             }
             /*!
              Sets the \a pen of legend. Pen affects the legend borders.
              */
             void QLegend::setPen(const QPen &pen)
             {
                 if (d_ptr->m_pen != pen) {
                     d_ptr->m_pen = pen;
                     update();
                     emit borderColorChanged(pen.color());
                 }
             }
             /*!
              Returns the pen used by legend
              */
             QPen QLegend::pen() const
             {
                 return d_ptr->m_pen;
             }
             void QLegend::setFont(const QFont &font)
             {
                 if (d_ptr->m_font != font) {
                     d_ptr->m_font = font;
                     foreach (QLegendMarker *marker, d_ptr->markers()) {
                         marker->setFont(d_ptr->m_font);
                     }
                     layout()->invalidate();
                     emit fontChanged(font);
                 }
             }
             QFont QLegend::font() const
             {
                 return d_ptr->m_font;
             }
             void QLegend::setBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_pen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QLegend::borderColor()
             {
                 return d_ptr->m_pen.color();
             }
             /*!
                 Set brush used to draw labels to \a brush.
             */
             void QLegend::setLabelBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelBrush != brush) {
                     d_ptr->m_labelBrush = brush;
                     foreach (QLegendMarker *marker, d_ptr->markers()) {
                         marker->setLabelBrush(d_ptr->m_labelBrush);
                         // Note: The pen of the marker rectangle could be exposed in the public QLegend API
                         // instead of mapping it from label brush color
                         marker->setPen(brush.color());
                     }
                     emit labelColorChanged(brush.color());
                 }
             }
             /*!
                 Brush used to draw labels.
             */
             QBrush QLegend::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             void QLegend::setLabelColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelBrush;
                 if (b.style() != Qt::SolidPattern || b.color() != color) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     setLabelBrush(b);
                 }
             }
             QColor QLegend::labelColor() const
             {
                 return d_ptr->m_labelBrush.color();
             }
             void QLegend::setAlignment(Qt::Alignment alignment)
             {
                 if (d_ptr->m_alignment != alignment) {
                     d_ptr->m_alignment = alignment;
                     layout()->invalidate();
                 }
             }
             Qt::Alignment QLegend::alignment() const
             {
                 return d_ptr->m_alignment;
             }
             /*!
              Detaches the legend from chart. Chart won't change layout of the legend.
              */
             void QLegend::detachFromChart()
             {
                 d_ptr->m_attachedToChart = false;
             //    layout()->invalidate();
                 d_ptr->m_chart->layout()->invalidate();
                 setParent(0);
             }
             /*!
              Attaches the legend to chart. Chart may change layout of the legend.
              */
             void QLegend::attachToChart()
             {
                 d_ptr->m_attachedToChart = true;
             //    layout()->invalidate();
                 d_ptr->m_chart->layout()->invalidate();
                 setParent(d_ptr->m_chart);
             }
             /*!
              Returns true, if legend is attached to chart.
              */
             bool QLegend::isAttachedToChart()
             {
                 return d_ptr->m_attachedToChart;
             }
             /*!
              Sets the visibility of legend background to \a visible
              */
             void QLegend::setBackgroundVisible(bool visible)
             {
                 if (d_ptr->m_backgroundVisible != visible) {
                     d_ptr->m_backgroundVisible = visible;
                     update();
                     emit backgroundVisibleChanged(visible);
                 }
             }
             /*!
              Returns the visibility of legend background
              */
             bool QLegend::isBackgroundVisible() const
             {
                 return d_ptr->m_backgroundVisible;
             }
             /*!
               Returns the list of markers in legend. The list can be filtered with \a series parameter.
               If \a series is given, only markers related to that series are returned.
             */
             QList<QLegendMarker*> QLegend::markers(QAbstractSeries *series) const
             {
                 return d_ptr->markers(series);
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::hideEvent(QHideEvent *event)
             {
                 if (isAttachedToChart())
                     d_ptr->m_presenter->layout()->invalidate();
                 QGraphicsWidget::hideEvent(event);
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::showEvent(QShowEvent *event)
             {
                 if (isAttachedToChart()) {
                     d_ptr->items()->setVisible(false);
                     layout()->invalidate();
                 }
                 QGraphicsWidget::showEvent(event);
                 //layout activation will show the items
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendPrivate::QLegendPrivate(ChartPresenter *presenter, QChart *chart, QLegend *q)
                 : q_ptr(q),
                   m_presenter(presenter),
                   m_layout(new LegendLayout(q)),
                   m_chart(chart),
                   m_items(new QGraphicsItemGroup(q)),
                   m_alignment(Qt::AlignTop),
                   m_brush(QBrush()),
                   m_pen(QPen()),
                   m_labelBrush(QBrush()),
                   m_diameter(5),
                   m_attachedToChart(true),
                   m_backgroundVisible(false)
             {
                 m_items->setHandlesChildEvents(false);
             }
             QLegendPrivate::~QLegendPrivate()
             {
             }
             void QLegendPrivate::setOffset(const QPointF &offset)
             {
                 m_layout->setOffset(offset.x(), offset.y());
             }
             QPointF QLegendPrivate::offset() const
             {
                 return m_layout->offset();
             }
             int QLegendPrivate::roundness(qreal size)
             {
                 return 100 * m_diameter / int(size);
             }
             QList<QLegendMarker*> QLegendPrivate::markers(QAbstractSeries *series)
             {
                 // Return all markers
                 if (!series) {
                     return m_markers;
                 }
                 // Create filtered list
                 QList<QLegendMarker *> markers;
                 foreach (QLegendMarker *marker, m_markers) {
                     if (marker->series() == series) {
                         markers.append(marker);
                     }
                 }
                 return markers;
             }
             void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series)
             {
                 if (m_series.contains(series)) {
                     return;
                 }
                 QList<QLegendMarker*> newMarkers = series->d_ptr->createLegendMarkers(q_ptr);
                 decorateMarkers(newMarkers);
                 addMarkers(newMarkers);
                 QObject::connect(series->d_ptr.data(), SIGNAL(countChanged()), this, SLOT(handleCountChanged()));
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 m_series.append(series);
                 m_items->setVisible(false);
                 m_layout->invalidate();
             }
             void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series)
             {
                 if (m_series.contains(series)) {
                     m_series.removeOne(series);
                 }
                 // Find out, which markers to remove
                 QList<QLegendMarker *> removed;
                 foreach (QLegendMarker *m, m_markers) {
                     if (m->series() == series) {
                         removed << m;
                     }
                 }
                 removeMarkers(removed);
                 QObject::disconnect(series->d_ptr.data(), SIGNAL(countChanged()), this, SLOT(handleCountChanged()));
                 QObject::disconnect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 m_layout->invalidate();
             }
             void QLegendPrivate::handleSeriesVisibleChanged()
             {
                 QAbstractSeries *series = qobject_cast<QAbstractSeries *> (sender());
                 Q_ASSERT(series);
                 foreach (QLegendMarker *marker, m_markers) {
                     if (marker->series() == series) {
                         marker->setVisible(series->isVisible());
                     }
                 }
                 m_layout->invalidate();
             }
             void QLegendPrivate::handleCountChanged()
             {
                 // Here we handle the changes in marker count.
                 // Can happen for example when pieslice(s) have been added to or removed from pieseries.
                 QAbstractSeriesPrivate *series = qobject_cast<QAbstractSeriesPrivate *> (sender());
                 QList<QLegendMarker *> createdMarkers = series->createLegendMarkers(q_ptr);
                 // Find out removed markers and created markers
                 QList<QLegendMarker *> removedMarkers;
                 foreach (QLegendMarker *oldMarker, m_markers) {
                     // we have marker, which is related to sender.
                     if (oldMarker->series() == series->q_ptr) {
                         bool found = false;
                         foreach(QLegendMarker *newMarker, createdMarkers) {
                             // New marker considered existing if:
                             // - d_ptr->relatedObject() is same for both markers.
                             if (newMarker->d_ptr->relatedObject() == oldMarker->d_ptr->relatedObject()) {
                                 // Delete the new marker, since we already have existing marker, that might be connected on user side.
                                 found = true;
                                 createdMarkers.removeOne(newMarker);
                                 delete newMarker;
                             }
                         }
                         if (!found) {
                             // No related object found for marker, add to removedMarkers list
                             removedMarkers << oldMarker;
                         }
                     }
                 }
                 removeMarkers(removedMarkers);
                 decorateMarkers(createdMarkers);
                 addMarkers(createdMarkers);
                 q_ptr->layout()->invalidate();
             }
             void QLegendPrivate::addMarkers(QList<QLegendMarker *> markers)
             {
                 foreach (QLegendMarker *marker, markers) {
                     m_items->addToGroup(marker->d_ptr.data()->item());
                     m_markers << marker;
                     m_markerHash.insert(marker->d_ptr->item(), marker);
                 }
             }
             void QLegendPrivate::removeMarkers(QList<QLegendMarker *> markers)
             {
                 foreach (QLegendMarker *marker, markers) {
                     marker->d_ptr->item()->setVisible(false);
                     m_items->removeFromGroup(marker->d_ptr->item());
                     m_markers.removeOne(marker);
                     m_markerHash.remove(marker->d_ptr->item());
                     delete marker;
                 }
             }
             void QLegendPrivate::decorateMarkers(QList<QLegendMarker *> markers)
             {
                 foreach (QLegendMarker *marker, markers) {
                     marker->setFont(m_font);
                     marker->setLabelBrush(m_labelBrush);
                 }
             }
             #include "moc_qlegend.cpp"
             #include "moc_qlegend_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegendmarker.cpp +1 -1

             /****************************************************************************
              **
              ** Copyright (C) 2013 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 "qlegendmarker.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
             #include "qlegend.h"
             #include "qlegend_p.h"
             #include "legendlayout_p.h"
             #include <QFontMetrics>
             #include <QGraphicsSceneEvent>
             #include <QAbstractSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegendMarker
-                \brief LegendMarker object
+                \brief LegendMarker object.
                 \mainclass
                 QLegendMarker is abstract object that can be used to access markers inside QLegend. Legend marker consists of two
                 items: The colored box, which reflects the color of series and label, which is the name of series (or label of slice/barset
                 in case of pie or bar series)
                 The QLegendMarker is always related to one series.
                 \image examples_percentbarchart_legend.png
                 \sa QLegend
             */
             /*!
                 \enum QLegendMarker::LegendMarkerType
                 The type of the legendmarker object.
                 \value LegendMarkerTypeArea
                 \value LegendMarkerTypeBar
                 \value LegendMarkerTypePie
                 \value LegendMarkerTypeXY
             */
             /*!
                 \fn virtual LegendMarkerType QLegendMarker::type() = 0;
                 Returns the type of legendmarker. Type depends of the related series. LegendMarkerTypeXY is used for all QXYSeries derived
                 classes.
             */
             /*!
                 \fn virtual QAbstractSeries* QLegendMarker::series() = 0;
                 Returns pointer to series, which is related to this marker. Marker is always related to some series.
             */
             /*!
               \fn void QLegendMarker::clicked();
               This signal is emitted, when marker is clicked with mouse.
             */
             /*!
               \fn void QLegendMarker::hovered(bool status);
               This signal is emitted, when mouse is hovered over marker. \a status is true, when mouse enters the marker
               and false when it leaves the marker.
             */
             /*!
                 \fn void QLegendMarker::labelChanged()
                 This signal is emitted when the label of the legend marker has changed.
             */
             /*!
                 \fn void QLegendMarker::labelBrushChanged()
                 This signal is emitted when the label brush of the legend marker has changed.
             */
             /*!
                 \fn void QLegendMarker::fontChanged()
                 This signal is emitted when the (label) font of the legend marker has changed.
             */
             /*!
                 \fn void QLegendMarker::penChanged()
                 This signal is emitted when the pen of the legend marker has changed.
             */
             /*!
                 \fn void QLegendMarker::brushChanged()
                 This signal is emitted when the brush of the legend marker has changed.
             */
             /*!
                 \fn void QLegendMarker::visibleChanged()
                 This signal is emitted when the visibility of the legend marker has changed.
             */
             /*!
                 \property QLegendMarker::label
                 Label of the marker. This is the text that is shown in legend.
             */
             /*!
                 \property QLegendMarker::labelBrush
                 Brush of the label
             */
             /*!
                 \property QLegendMarker::font
                 Font of the label
             */
             /*!
                 \property QLegendMarker::pen
                 Pen of the marker. This is the outline of the colored square.
             */
             /*!
                 \property QLegendMarker::brush
                 Brush of the marker. This is the inside of the colored square.
             */
             /*!
                 \property QLegendMarker::visible
                 Visibility of the legend marker. Affects label and the colored square.
             */
             /*!
                 \internal
              */
             QLegendMarker::QLegendMarker(QLegendMarkerPrivate &d, QObject *parent) :
                 QObject(parent),
                 d_ptr(&d)
             {
                 d_ptr->m_item->setVisible(d_ptr->series()->isVisible());
             }
             /*!
               Destructor of marker
             */
             QLegendMarker::~QLegendMarker()
             {
             }
             /*!
               Returns the label of the marker.
             */
             QString QLegendMarker::label() const
             {
                 return d_ptr->m_item->label();
             }
             /*!
               Sets the \a label of marker. Note that changing name of series will also change label of its marker.
             */
             void QLegendMarker::setLabel(const QString &label)
             {
                 if (label.isEmpty()) {
                     d_ptr->m_customLabel = false;
                 } else {
                     d_ptr->m_customLabel = true;
                     d_ptr->m_item->setLabel(label);
                 }
             }
             /*!
               Returns the brush which is used to draw label.
             */
             QBrush QLegendMarker::labelBrush() const
             {
                 return d_ptr->m_item->labelBrush();
             }
             /*!
               Sets the \a brush of label
             */
             void QLegendMarker::setLabelBrush(const QBrush &brush)
             {
                 d_ptr->m_item->setLabelBrush(brush);
             }
             /*!
               Retuns the font of label
             */
             QFont QLegendMarker::font() const
             {
                 return d_ptr->m_item->font();
             }
             /*!
               Sets the \a font of label
             */
             void QLegendMarker::setFont(const QFont &font)
             {
                 d_ptr->m_item->setFont(font);
             }
             /*!
               Returns the pen of marker item
             */
             QPen QLegendMarker::pen() const
             {
                 return d_ptr->m_item->pen();
             }
             /*!
               Sets the \a pen of marker item
             */
             void QLegendMarker::setPen(const QPen &pen)
             {
                 if (pen == QPen(Qt::NoPen)) {
                     d_ptr->m_customPen = false;
                 } else {
                     d_ptr->m_customPen = true;
                     d_ptr->m_item->setPen(pen);
                 }
             }
             /*!
               Returns the brush of marker item
             */
             QBrush QLegendMarker::brush() const
             {
                 return d_ptr->m_item->brush();
             }
             /*!
               Sets the \a brush of marker item. Note that changing color of the series also changes this.
             */
             void QLegendMarker::setBrush(const QBrush &brush)
             {
                 if (brush == QBrush(Qt::NoBrush)) {
                     d_ptr->m_customBrush = false;
                 } else {
                     d_ptr->m_customBrush = true;
                     d_ptr->m_item->setBrush(brush);
                 }
             }
             /*!
               Returns visibility of the marker
             */
             bool QLegendMarker::isVisible() const
             {
                 return d_ptr->m_item->isVisible();
             }
             /*!
               Sets markers visibility to \a visible
             */
             void QLegendMarker::setVisible(bool visible)
             {
                 d_ptr->m_item->setVisible(visible);
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendMarkerPrivate::QLegendMarkerPrivate(QLegendMarker *q, QLegend *legend) :
                 m_legend(legend),
                 m_customLabel(false),
                 m_customBrush(false),
                 m_customPen(false),
                 q_ptr(q)
             {
                 m_item = new LegendMarkerItem(this);
             }
             QLegendMarkerPrivate::~QLegendMarkerPrivate()
             {
                 delete m_item;
             }
             void QLegendMarkerPrivate::invalidateLegend()
             {
                 m_legend->d_ptr->m_layout->invalidate();
             }
             #include "moc_qlegendmarker.cpp"
             #include "moc_qlegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qpielegendmarker.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qpielegendmarker.h"
             #include "qpielegendmarker_p.h"
             #include <QPieSeries>
             #include <QPieSlice>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieLegendMarker
-                \brief LegendMarker object
+                \brief LegendMarker object.
                 \mainclass
                 QPieLegendMarker is related to QPieSeries. With QPieSeries, each slice of pie is related to one marker in QLegend.
                 \sa QLegend QPieSeries QPieSlice
             */
             /*!
               \fn virtual LegendMarkerType QPieLegendMarker::type()
               Returns QLegendMarker::LegendMarkerTypePie
             */
             /*!
               \internal
             */
             QPieLegendMarker::QPieLegendMarker(QPieSeries *series, QPieSlice *slice, QLegend *legend, QObject *parent) :
                 QLegendMarker(*new QPieLegendMarkerPrivate(this,series,slice,legend), parent)
             {
                 d_ptr->updated();
             }
             /*!
               Destructor
             */
             QPieLegendMarker::~QPieLegendMarker()
             {
             }
             /*!
                 \internal
             */
             QPieLegendMarker::QPieLegendMarker(QPieLegendMarkerPrivate &d, QObject *parent) :
                 QLegendMarker(d, parent)
             {
             }
             /*!
               Returns the related series of marker.
             */
             QPieSeries* QPieLegendMarker::series()
             {
                 Q_D(QPieLegendMarker);
                 return d->m_series;
             }
             /*!
               Returns the related slice of marker.
             */
             QPieSlice* QPieLegendMarker::slice()
             {
                 Q_D(QPieLegendMarker);
                 return d->m_slice;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieLegendMarkerPrivate::QPieLegendMarkerPrivate(QPieLegendMarker *q, QPieSeries *series, QPieSlice *slice, QLegend *legend) :
                 QLegendMarkerPrivate(q,legend),
                 q_ptr(q),
                 m_series(series),
                 m_slice(slice)
             {
                 QObject::connect(m_slice, SIGNAL(labelChanged()), this, SLOT(updated()));
                 QObject::connect(m_slice, SIGNAL(brushChanged()), this, SLOT(updated()));
                 QObject::connect(m_slice, SIGNAL(penChanged()), this, SLOT(updated()));
             }
             QPieLegendMarkerPrivate::~QPieLegendMarkerPrivate()
             {
             }
             QPieSeries* QPieLegendMarkerPrivate::series()
             {
                 return m_series;
             }
             QObject* QPieLegendMarkerPrivate::relatedObject()
             {
                 return m_slice;
             }
             void QPieLegendMarkerPrivate::updated()
             {
                 bool labelChanged = false;
                 bool brushChanged = false;
                 bool penChanged = false;
                 if (!m_customPen && (m_item->pen() != m_slice->pen())) {
                     m_item->setPen(m_slice->pen());
                     penChanged = true;
                 }
                 if (!m_customBrush && (m_item->brush() != m_slice->brush())) {
                     m_item->setBrush(m_slice->brush());
                     brushChanged = true;
                 }
                 if (!m_customLabel && (m_item->label() != m_slice->label())) {
                     m_item->setLabel(m_slice->label());
                     labelChanged = true;
                 }
                 invalidateLegend();
                 if (labelChanged)
                     emit q_ptr->labelChanged();
                 if (brushChanged)
                     emit q_ptr->brushChanged();
                 if (penChanged)
                     emit q_ptr->penChanged();
             }
             #include "moc_qpielegendmarker.cpp"
             #include "moc_qpielegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qxylegendmarker.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qxylegendmarker.h"
             #include "qxylegendmarker_p.h"
             #include "qxyseries_p.h"
             #include <QXYSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYLegendMarker
-                \brief QXYLegendMarker object
+                \brief QXYLegendMarker object.
                 \mainclass
                 QXYLegendMarker is related to QXYSeries derived classes. Each marker is related to one series.
                 \sa QLegend QXYSeries QSplineSeries QScatterSeries QLineSeries
             */
             /*!
               \fn virtual LegendMarkerType QXYLegendMarker::type()
               Returns QLegendMarker::LegendMarkerTypeXY
             */
             /*!
               \internal
             */
             QXYLegendMarker::QXYLegendMarker(QXYSeries *series, QLegend *legend, QObject *parent) :
                 QLegendMarker(*new QXYLegendMarkerPrivate(this,series,legend), parent)
             {
                 d_ptr->updated();
             }
             /*!
               Destructor
             */
             QXYLegendMarker::~QXYLegendMarker()
             {
             }
             /*!
                 \internal
             */
             QXYLegendMarker::QXYLegendMarker(QXYLegendMarkerPrivate &d, QObject *parent) :
                 QLegendMarker(d, parent)
             {
             }
             /*!
               Returns the related series
             */
             QXYSeries* QXYLegendMarker::series()
             {
                 Q_D(QXYLegendMarker);
                 return d->m_series;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYLegendMarkerPrivate::QXYLegendMarkerPrivate(QXYLegendMarker *q, QXYSeries *series, QLegend *legend) :
                 QLegendMarkerPrivate(q,legend),
                 q_ptr(q),
                 m_series(series)
             {
                 QObject::connect(m_series, SIGNAL(nameChanged()), this, SLOT(updated()));
                 QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(updated()));
             }
             QXYLegendMarkerPrivate::~QXYLegendMarkerPrivate()
             {
             }
             QAbstractSeries* QXYLegendMarkerPrivate::series()
             {
                 return m_series;
             }
             QObject* QXYLegendMarkerPrivate::relatedObject()
             {
                 return m_series;
             }
             void QXYLegendMarkerPrivate::updated()
             {
                 bool labelChanged = false;
                 bool brushChanged = false;
                 if (!m_customLabel && (m_item->label() != m_series->name())) {
                     m_item->setLabel(m_series->name());
                     labelChanged = true;
                 }
                 if (m_series->type()== QAbstractSeries::SeriesTypeScatter)  {
                     if (!m_customBrush && (m_item->brush() != m_series->brush())) {
                         m_item->setBrush(m_series->brush());
                         brushChanged = true;
                     }
                 } else {
                     QBrush emptyBrush;
                     if (!m_customBrush
                         && (m_item->brush() == emptyBrush
                             || m_item->brush().color() != m_series->pen().color())) {
                         m_item->setBrush(QBrush(m_series->pen().color()));
                         brushChanged = true;
                     }
                 }
                 invalidateLegend();
                 if (labelChanged)
                     emit q_ptr->labelChanged();
                 if (brushChanged)
                     emit q_ptr->brushChanged();
             }
             #include "moc_qxylegendmarker.cpp"
             #include "moc_qxylegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qhpiemodelmapper.cpp +7 -3

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qhpiemodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHPieModelMapper
                 \mainclass
                 Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
                 Horizontal model mapper is used to create a connection between QPieSeries and QAbstractItemModel derived model object that keeps the consecutive pie slices data in rows.
                 It is possible to use both QAbstractItemModel and QPieSeries model API. QHPieModelMapper makes sure that Pie and the model are kept in sync.
                 \note Used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
                 \qmlclass HPieModelMapper QHPieModelMapper
                 HPieModelMapper allows you to use your own QAbstractItemModel derived model with data in rows as a data source
                 for a pie series. It is possible to use both QAbstractItemModel and PieSeries data API to manipulate data.
                 HPieModelMapper keeps the Pie and the model in sync.
                 The following QML example would create a pie series with four slices (assuming the model has
                 at least five columns). Each slice would contain a label from row 1 and a value from row 2.
                 \code
                     HPieModelMapper {
                         series: pieSeries
                         model: customModel
                         labelsRow: 1
                         valuesRow: 2
                         firstColumn: 1
                         columnCount: 4
                     }
                 \endcode
             */
             /*!
                 \property QHPieModelMapper::series
                 \brief Defines the QPieSeries object that is used by the mapper.
                 All the data in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \qmlproperty PieSeries HPieModelMapper::series
                 Defines the PieSeries object that is used by the mapper. If you define the mapper element as a child for a
                 PieSeries, leave this property undefined. All the data in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data).
             */
             /*!
                 \property QHPieModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \qmlproperty SomeModel HPieModelMapper::model
                 The QAbstractItemModel based model that is used by the mapper. You need to implement the model and expose it to
                 QML as shown in \l {QML Custom Model} demo application. Note: the model has to support adding/removing rows/columns
                 and modifying the data of the cells.
             */
             /*!
                 \property QHPieModelMapper::valuesRow
-                \brief Defines which row of the model is kept in sync with the values of the pie's slices
+                \brief Defines which row of the model is kept in sync with the values of the pie's slices.
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int HPieModelMapper::valuesRow
                 Defines which row of the model is kept in sync with the values of the pie's slices. Default value is: -1 (invalid
                 mapping).
             */
             /*!
                 \property QHPieModelMapper::labelsRow
-                \brief Defines which row of the model is kept in sync with the labels of the pie's slices
+                \brief Defines which row of the model is kept in sync with the labels of the pie's slices.
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int HPieModelMapper::labelsRow
                 Defines which row of the model is kept in sync with the labels of the pie's slices
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \property QHPieModelMapper::firstColumn
                 \brief Defines which column of the model contains the first slice value.
                 Minimal and default value is: 0
             */
             /*!
                 \qmlproperty int HPieModelMapper::firstColumn
                 Defines which column of the model contains the first slice value.
                 The default value is 0.
             */
             /*!
                 \property QHPieModelMapper::columnCount
-                \brief Defines the number of columns of the model that are mapped as the data for QPieSeries
+                \brief Defines the number of columns of the model that are mapped as the data for QPieSeries.
                 Minimal and default value is: -1 (count limited by the number of columns in the model)
             */
             /*!
                 \qmlproperty int HPieModelMapper::columnCount
                 Defines the number of columns of the model that are mapped as the data for QPieSeries. The default value is
                 -1 (count limited by the number of columns in the model)
             */
             /*!
                 \fn void QHPieModelMapper::seriesReplaced()
                 Emitted when the series to which mapper is connected to has changed.
             */
             /*!
                 \fn void QHPieModelMapper::modelReplaced()
                 Emitted when the model to which mapper is connected to has changed.
             */
             /*!
                 \fn void QHPieModelMapper::valuesRowChanged()
                 Emitted when the valuesRow has changed.
             */
             /*!
                 \fn void QHPieModelMapper::labelsRowChanged()
                 Emitted when the labelsRow has changed.
             */
             /*!
                 \fn void QHPieModelMapper::firstColumnChanged()
                 Emitted when the firstColumn has changed.
             */
             /*!
                 \fn void QHPieModelMapper::columnCountChanged()
                 Emitted when the columnCount has changed.
             */
             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QHPieModelMapper::QHPieModelMapper(QObject *parent) :
                 QPieModelMapper(parent)
             {
                 setOrientation(Qt::Horizontal);
             }
             QAbstractItemModel *QHPieModelMapper::model() const
             {
                 return QPieModelMapper::model();
             }
             void QHPieModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model != QPieModelMapper::model()) {
                     QPieModelMapper::setModel(model);
                     emit modelReplaced();
                 }
             }
             QPieSeries *QHPieModelMapper::series() const
             {
                 return QPieModelMapper::series();
             }
             void QHPieModelMapper::setSeries(QPieSeries *series)
             {
                 if (series != QPieModelMapper::series()) {
                     QPieModelMapper::setSeries(series);
                     emit seriesReplaced();
                 }
             }
             /*!
                 Returns which row of the model is kept in sync with the values of the pie's slices
             */
             int QHPieModelMapper::valuesRow() const
             {
                 return valuesSection();
             }
             /*!
                 Sets the model row that is kept in sync with the pie slices values.
                 Parameter \a valuesRow specifies the row of the model.
             */
             void QHPieModelMapper::setValuesRow(int valuesRow)
             {
                 if (valuesRow != valuesSection()) {
                     setValuesSection(valuesRow);
                     emit valuesRowChanged();
                 }
             }
             /*!
                 Returns which row of the model is kept in sync with the labels of the pie's slices
             */
             int QHPieModelMapper::labelsRow() const
             {
                 return labelsSection();
             }
             /*!
                 Sets the model row that is kept in sync with the pie's slices labels.
                 Parameter \a labelsRow specifies the row of the model.
             */
             void QHPieModelMapper::setLabelsRow(int labelsRow)
             {
                 if (labelsRow != labelsSection()) {
                     setLabelsSection(labelsRow);
                     emit labelsRowChanged();
                 }
             }
             int QHPieModelMapper::firstColumn() const
             {
                 return first();
             }
             void QHPieModelMapper::setFirstColumn(int firstColumn)
             {
                 if (firstColumn != first()) {
                     setFirst(firstColumn);
                     emit firstColumnChanged();
                 }
             }
             int QHPieModelMapper::columnCount() const
             {
                 return count();
             }
             void QHPieModelMapper::setColumnCount(int columnCount)
             {
                 if (columnCount != count()) {
                     setCount(columnCount);
                     emit columnCountChanged();
                 }
             }
             #include "moc_qhpiemodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qabstractaxis.h"
             #include "pieanimation_p.h"
             #include "charthelpers_p.h"
             #include "qpielegendmarker.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries
-                \brief Pie series API for QtCommercial Charts
+                \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} or \l {DonutChart Example} {donut chart example} to learn how to use QPieSeries.
                 \table 100%
                 \row
                 \o \image examples_piechart.png
                 \o \image examples_donutchart.png
                 \endtable
             */
             /*!
                 \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
                 When setting this property the holeSize property is adjusted if necessary, to ensure that the hole size is not greater than the outer size.
                 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::holeSize
                 \brief Defines the donut hole size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (full pie drawn, without any hole inside).
                 \o 1.0 is the maximum size that can fit the chart. (donut has no width)
                 \endlist
                 The value is never greater then size property.
                 Default value is 0.0.
             */
             /*!
                 \qmlproperty real PieSeries::holeSize
                 Defines the donut hole size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (full pie drawn, without any hole inside).
                 \o 1.0 is the maximum size that can fit the chart. (donut has no width)
                 \endlist
                 When setting this property the size property is adjusted if necessary, to ensure that the inner size is not greater than the outer size.
                 Default value is 0.0.
             */
             /*!
                 \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::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::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 successful, 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)
             {
                 Q_D(QPieSeries);
                 QObject::connect(this, SIGNAL(countChanged()), d, SIGNAL(countChanged()));
             }
             /*!
                 Destroys the series and its slices.
             */
             QPieSeries::~QPieSeries()
             {
                 // NOTE: d_prt destroyed by QObject
                 clear();
             }
             /*!
-                Returns QChartSeries::SeriesTypePie.
+                Returns QAbstractSeries::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 successful.
             */
             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;
                     if (!isValidValue(s->value()))
                         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.
                 Returns NULL if value is NaN, Inf or -Inf and no slice is added to the series.
             */
             QPieSlice *QPieSeries::append(QString label, qreal value)
             {
                 if (isValidValue(value)) {
                     QPieSlice *slice = new QPieSlice(label, value);
                     append(slice);
                     return slice;
                 } else {
                     return 0;
                 }
             }
             /*!
                 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 successful.
             */
             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;
                 if (!isValidValue(slice->value()))
                     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 successful.
             */
             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;
             }
             /*!
                 Takes a single \a slice from the series. Does not destroy the slice object.
                 \note The series remains as the slice's parent object. You must set the
                 parent object to take full ownership.
                 Returns true if take was successful.
             */
             bool QPieSeries::take(QPieSlice *slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice))
                     return false;
                 QPieSlicePrivate::fromSlice(slice)->m_series = 0;
                 slice->disconnect(d);
                 d->updateDerivativeData();
                 emit removed(QList<QPieSlice *>() << slice);
                 emit countChanged();
                 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);
                 d->updateDerivativeData();
                 emit removed(slices);
                 emit countChanged();
                 foreach (QPieSlice *s, slices)
                     delete s;
             }
             /*!
                 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::setHoleSize(qreal holeSize)
             {
                 Q_D(QPieSeries);
                 holeSize = qBound((qreal)0.0, holeSize, (qreal)1.0);
                 d->setSizes(holeSize, qMax(d->m_pieRelativeSize, holeSize));
             }
             qreal QPieSeries::holeSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_holeRelativeSize;
             }
             void QPieSeries::setHorizontalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (relativePosition < 0.0)
                     relativePosition = 0.0;
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
                 if (!qFuzzyCompare(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 (!qFuzzyCompare(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);
                 relativeSize = qBound((qreal)0.0, relativeSize, (qreal)1.0);
                 d->setSizes(qMin(d->m_holeRelativeSize, relativeSize), relativeSize);
             }
             qreal QPieSeries::pieSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeSize;
             }
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (qFuzzyCompare(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 (qFuzzyCompare(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);
             }
             /*!
                 Sets the all the slice labels \a position
                 Note that this affects only the current slices in the series.
                 If user adds a new slice the default label position is LabelOutside
                 \sa QPieSlice::labelPosition(), QPieSlice::setLabelPosition()
             */
             void QPieSeries::setLabelsPosition(QPieSlice::LabelPosition position)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice *s, d->m_slices)
                     s->setLabelPosition(position);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             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),
                 m_holeRelativeSize(0.0)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
             }
             void QPieSeriesPrivate::updateDerivativeData()
             {
                 // calculate sum of all slices
                 qreal sum = 0;
                 foreach (QPieSlice *s, m_slices)
                     sum += s->value();
                 if (!qFuzzyCompare(m_sum, sum)) {
                     m_sum = sum;
                     emit q_func()->sumChanged();
                 }
                 // nothing to show..
                 if (qFuzzyCompare(m_sum, 0))
                     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();
             }
             void QPieSeriesPrivate::setSizes(qreal innerSize, qreal outerSize)
             {
                 bool changed = false;
                 if (!qFuzzyCompare(m_holeRelativeSize, innerSize)) {
                     m_holeRelativeSize = innerSize;
                     changed = true;
                 }
                 if (!qFuzzyCompare(m_pieRelativeSize, outerSize)) {
                     m_pieRelativeSize = outerSize;
                     changed = true;
                 }
                 if (changed)
                     emit pieSizeChanged();
             }
             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::initializeDomain()
             {
                 // does not apply to pie
             }
             void QPieSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QPieSeries);
                 PieChartItem *pie = new PieChartItem(q,parent);
                 m_item.reset(pie);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             void QPieSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
             {
                 PieChartItem *item = static_cast<PieChartItem *>(m_item.data());
                 Q_ASSERT(item);
                 if (options.testFlag(QChart::SeriesAnimations)) {
                     item->setAnimation(new PieAnimation(item));
                 }else{
                     item->setAnimation(0);
                 }
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             QList<QLegendMarker*> QPieSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QPieSeries);
                 QList<QLegendMarker*> markers;
                 foreach(QPieSlice* slice, q->slices()) {
                     QPieLegendMarker* marker = new QPieLegendMarker(q,slice,legend);
                     markers << marker;
                 }
                 return markers;
             }
             void QPieSeriesPrivate::initializeAxes()
             {
             }
             QAbstractAxis::AxisType QPieSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeNoAxis;
             }
             QAbstractAxis* QPieSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return 0;
             }
             void QPieSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 //Q_Q(QPieSeries);
                 //const QList<QColor>& colors = theme->seriesColors();
                 const QList<QGradient>& gradients = theme->seriesGradients();
                 for (int i(0); i < m_slices.count(); i++) {
                     QColor penColor = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0);
                     // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                     qreal pos = (qreal)(i + 1) / (qreal) m_slices.count();
                     QColor brushColor = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), pos);
                     QPieSlice *s = m_slices.at(i);
                     QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
                     if (forced || d->m_data.m_slicePen.isThemed())
                         d->setPen(penColor, true);
                     if (forced || d->m_data.m_sliceBrush.isThemed())
                         d->setBrush(brushColor, true);
                     if (forced || d->m_data.m_labelBrush.isThemed())
                         d->setLabelBrush(theme->labelBrush().color(), true);
                     if (forced || d->m_data.m_labelFont.isThemed())
                         d->setLabelFont(theme->labelFont(), true);
                 }
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qvpiemodelmapper.cpp +7 -3

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qvpiemodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QVPieModelMapper
                 \mainclass
                 Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
                 Vertical model mapper is used to create a connection between QPieSeries and QAbstractItemModel derived model object that keeps the consecutive pie slices data in columns.
                 It is possible to use both QAbstractItemModel and QPieSeries model API. QVPieModelMapper makes sure that Pie and the model are kept in sync.
                 \note Used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
                 \qmlclass VPieModelMapper QVPieModelMapper
                 VPieModelMapper allows you to use your own QAbstractItemModel derived model with data in columns as a data source
                 for a pie series. It is possible to use both QAbstractItemModel and PieSeries data API to manipulate data.
                 VPieModelMapper keeps the Pie and the model in sync.
                 The following QML example would create a pie series with four slices (assuming the model has at least five rows).
                 Each slice would contain a label from column 1 and a value from column 2.
                 \code
                     VPieModelMapper {
                         series: pieSeries
                         model: customModel
                         labelsColumn: 1
                         valuesColumn: 2
                         firstRow: 1
                         rowCount: 4
                     }
                 \endcode
             */
             /*!
                 \property QVPieModelMapper::series
                 \brief Defines the QPieSeries object that is used by the mapper.
                 All the data in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \qmlproperty PieSeries VPieModelMapper::series
                 Defines the PieSeries object that is used by the mapper. If you define the mapper element as a child for a
                 PieSeries, leave this property undefined. All the data in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data).
             */
             /*!
                 \property QVPieModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \qmlproperty SomeModel VPieModelMapper::model
                 The QAbstractItemModel based model that is used by the mapper. You need to implement the model and expose it to
                 QML as shown in \l {QML Custom Model} demo application. Note: the model has to support adding/removing rows/columns
                 and modifying the data of the cells.
             */
             /*!
                 \property QVPieModelMapper::valuesColumn
-                \brief Defines which column of the model is kept in sync with the values of the pie's slices
+                \brief Defines which column of the model is kept in sync with the values of the pie's slices.
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int VPieModelMapper::valuesColumn
                 Defines which column of the model is kept in sync with the values of the pie's slices. Default value is -1 (invalid
                 mapping).
             */
             /*!
                 \property QVPieModelMapper::labelsColumn
-                \brief Defines which column of the model is kept in sync with the labels of the pie's slices
+                \brief Defines which column of the model is kept in sync with the labels of the pie's slices.
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int VPieModelMapper::labelsColumn
                 Defines which column of the model is kept in sync with the labels of the pie's slices. Default value is -1 (invalid
                 mapping).
             */
             /*!
                 \property QVPieModelMapper::firstRow
                 \brief Defines which row of the model contains the first slice value.
                 Minimal and default value is: 0
             */
             /*!
                 \qmlproperty int VPieModelMapper::firstRow
                 Defines which row of the model contains the first slice value.
                 The default value is 0.
             */
             /*!
                 \property QVPieModelMapper::rowCount
-                \brief Defines the number of rows of the model that are mapped as the data for QPieSeries
+                \brief Defines the number of rows of the model that are mapped as the data for QPieSeries.
                 Minimal and default value is: -1 (count limited by the number of rows in the model)
             */
             /*!
                 \qmlproperty int VPieModelMapper::columnCount
                 Defines the number of rows of the model that are mapped as the data for QPieSeries. The default value is
                 -1 (count limited by the number of rows in the model)
             */
             /*!
                 \fn void QVPieModelMapper::seriesReplaced()
                 Emitted when the series to which mapper is connected to has changed.
             */
             /*!
                 \fn void QVPieModelMapper::modelReplaced()
                 Emitted when the model to which mapper is connected to has changed.
             */
             /*!
                 \fn void QVPieModelMapper::valuesColumnChanged()
                 Emitted when the valuesColumn has changed.
             */
             /*!
                 \fn void QVPieModelMapper::labelsColumnChanged()
                 Emitted when the labelsColumn has changed.
             */
             /*!
                 \fn void QVPieModelMapper::firstRowChanged()
                 Emitted when the firstRow has changed.
             */
             /*!
                 \fn void QVPieModelMapper::rowCountChanged()
                 Emitted when the rowCount has changed.
             */
             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QVPieModelMapper::QVPieModelMapper(QObject *parent) :
                 QPieModelMapper(parent)
             {
                 QPieModelMapper::setOrientation(Qt::Vertical);
             }
             QAbstractItemModel *QVPieModelMapper::model() const
             {
                 return QPieModelMapper::model();
             }
             void QVPieModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model != QPieModelMapper::model()) {
                     QPieModelMapper::setModel(model);
                     emit modelReplaced();
                 }
             }
             QPieSeries *QVPieModelMapper::series() const
             {
                 return QPieModelMapper::series();
             }
             void QVPieModelMapper::setSeries(QPieSeries *series)
             {
                 if (series != QPieModelMapper::series()) {
                     QPieModelMapper::setSeries(series);
                     emit seriesReplaced();
                 }
             }
             /*!
                 Returns which column of the model is kept in sync with the values of the pie's slices
             */
             int QVPieModelMapper::valuesColumn() const
             {
                 return QPieModelMapper::valuesSection();
             }
             /*!
                 Sets the model column that is kept in sync with the pie slices values.
                 Parameter \a valuesColumn specifies the row of the model.
             */
             void QVPieModelMapper::setValuesColumn(int valuesColumn)
             {
                 if (valuesColumn != valuesSection()) {
                     QPieModelMapper::setValuesSection(valuesColumn);
                     emit valuesColumnChanged();
                 }
             }
             /*!
                 Returns which column of the model is kept in sync with the labels of the pie's slices
             */
             int QVPieModelMapper::labelsColumn() const
             {
                 return QPieModelMapper::labelsSection();
             }
             /*!
                 Sets the model column that is kept in sync with the pie's slices labels.
                 Parameter \a labelsColumn specifies the row of the model.
             */
             void QVPieModelMapper::setLabelsColumn(int labelsColumn)
             {
                 if (labelsColumn != labelsSection()) {
                     QPieModelMapper::setLabelsSection(labelsColumn);
                     emit labelsColumnChanged();
                 }
             }
             int QVPieModelMapper::firstRow() const
             {
                 return first();
             }
             void QVPieModelMapper::setFirstRow(int firstRow)
             {
                 if (firstRow != first()) {
                     setFirst(firstRow);
                     emit firstRowChanged();
                 }
             }
             int QVPieModelMapper::rowCount() const
             {
                 return count();
             }
             void QVPieModelMapper::setRowCount(int rowCount)
             {
                 if (rowCount != count()) {
                     setCount(rowCount);
                     emit rowCountChanged();
                 }
             }
             #include "moc_qvpiemodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qabstractseries.cpp +3 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "chartdataset_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "chartitem_p.h"
             #include "xydomain_p.h"
             #include "xlogydomain_p.h"
             #include "logxydomain_p.h"
             #include "logxlogydomain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractSeries
                 \brief Base class for all QtCommercial Chart series.
                 \mainclass
                 Usually you use the series type specific inherited classes instead of the base class.
                 \sa QXYSeries, QLineSeries, QSplineSeries, QScatterSeries, QAreaSeries, QAbstractBarSeries, QStackedBarSeries,
                 QPercentBarSeries, QPieSeries
             */
             /*!
                 \qmlclass AbstractSeries
                 AbstractSeries is the base class for all series.
                 The class cannot be instantiated by the user.
             */
             /*!
                 \enum QAbstractSeries::SeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
                 \value SeriesTypeHorizontalBar
                 \value SeriesTypeHorizontalStackedBar
                 \value SeriesTypeHorizontalPercentBar
             */
             /*!
                 \property QAbstractSeries::type
                 The type of the series.
             */
             /*!
                 \qmlproperty ChartView.SeriesType AbstractSeries::type
                 The type of the series.
             */
             /*!
                 \property QAbstractSeries::name
                 \brief name of the series property. The name is shown in legend for QXYSeries.
             */
             /*!
                 \qmlproperty string AbstractSeries::name
                 Name of the series. The name is shown in legend for QXYSeries.
             */
             /*!
                 \fn void QAbstractSeries::nameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onNameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \property QAbstractSeries::visible
                 \brief whether the series is visible or not; true by default.
             */
             /*!
                 \qmlproperty bool AbstractSeries::visible
                 Visibility of the series. True by default.
             */
             /*!
                 \fn void QAbstractSeries::visibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onVisibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \property QAbstractSeries::opacity
                 \brief The opacity of the series.
                 By default the opacity is 1.0. The valid values range from 0.0 (transparent) to 1.0 (opaque).
             */
             /*!
                 \qmlproperty real AbstractSeries::opacity
                 The opacity of the series. By default the opacity is 1.0.
                 The valid values range from 0.0 (transparent) to 1.0 (opaque).
             */
             /*!
                 \fn void QAbstractSeries::opacityChanged()
                 Emitted when the opacity of the series changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onOpacityChanged()
                 Emitted when the opacity of the series changes.
             */
             /*!
                 \internal
                 \brief Constructs QAbstractSeries object with \a parent.
             */
             QAbstractSeries::QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent) :
                 QObject(parent),
                 d_ptr(&d)
             {
             }
             /*!
                 \brief Virtual destructor for the chart series.
             */
             QAbstractSeries::~QAbstractSeries()
             {
                 if (d_ptr->m_chart)
                     qFatal("Series still bound to a chart when destroyed!");
             }
             void QAbstractSeries::setName(const QString &name)
             {
                 if (name != d_ptr->m_name) {
                     d_ptr->m_name = name;
                     emit nameChanged();
                 }
             }
             QString QAbstractSeries::name() const
             {
                 return d_ptr->m_name;
             }
             void QAbstractSeries::setVisible(bool visible)
             {
                 if (visible != d_ptr->m_visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged();
                 }
             }
             bool QAbstractSeries::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             qreal QAbstractSeries::opacity() const
             {
                 return d_ptr->m_opacity;
             }
             void QAbstractSeries::setOpacity(qreal opacity)
             {
                 if (opacity != d_ptr->m_opacity) {
                     d_ptr->m_opacity = opacity;
                     emit opacityChanged();
                 }
             }
             /*!
                 \brief Returns the chart where series belongs to.
                 Set automatically when the series is added to the chart
                 and unset when the series is removed from the chart.
             */
             QChart *QAbstractSeries::chart() const
             {
                 return d_ptr->m_chart;
             }
             /*!
-                \brief Sets the visibility of the series to true
+                \brief Sets the visibility of the series to true.
                 \sa setVisible(), isVisible()
             */
             void QAbstractSeries::show()
             {
                 setVisible(true);
             }
             /*!
-                \brief Sets the visibility of the series to false
+                \brief Sets the visibility of the series to false.
                 \sa setVisible(), isVisible()
             */
             void QAbstractSeries::hide()
             {
                 setVisible(false);
             }
             /*!
              Attach \a axis to the series.
              \return true if the axis was attached successfully, false otherwise.
              \sa QChart::addAxis(), QChart::createDefaultAxes()
              */
             bool QAbstractSeries::attachAxis(QAbstractAxis* axis)
             {
                 if(d_ptr->m_chart) {
                     return d_ptr->m_chart->d_ptr->m_dataset->attachAxis(this, axis);
                 } else {
                     qWarning()<<"Series not in the chart. Please addSeries to chart first.";
                     return false;
                 }
             }
             /*!
              Detach \a axis from the series.
              \return true if the axis was detached successfully, false otherwise.
              \sa QChart::removeAxis()
              */
             bool QAbstractSeries::detachAxis(QAbstractAxis* axis)
             {
                 if(d_ptr->m_chart) {
                     return d_ptr->m_chart->d_ptr->m_dataset->detachAxis(this, axis);
                 }
                 else {
                     qWarning()<<"Series not in the chart. Please addSeries to chart first.";
                     return false;
                 }
             }
             /*!
              Returns the list of axes attached to the series. Usually there is an x-axis and a y-axis attached to a series, except
              in case of a QPieSeries, which does not have any axes attached.
              \sa attachAxis(), detachAxis()
              */
             QList<QAbstractAxis*> QAbstractSeries::attachedAxes()
             {
                 return d_ptr->m_axes;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries *q)
                 : q_ptr(q),
                   m_chart(0),
                   m_item(0),
                   m_domain(new XYDomain()),
                   m_visible(true),
                   m_opacity(1.0)
             {
             }
             QAbstractSeriesPrivate::~QAbstractSeriesPrivate()
             {
             }
             void QAbstractSeriesPrivate::setDomain(AbstractDomain* domain)
             {
                 Q_ASSERT(domain);
                 if(m_domain.data()!=domain) {
                     if(!m_item.isNull()) QObject::disconnect(m_domain.data(), SIGNAL(updated()), m_item.data(), SLOT(handleDomainUpdated()));
                     m_domain.reset(domain);
                     if(!m_item.isNull()) {
                         QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
                         m_item->handleDomainUpdated();
                     }
                 }
             }
             void QAbstractSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_ASSERT(!m_item.isNull());
                 Q_UNUSED(parent);
                 QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
             }
             void QAbstractSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 Q_UNUSED(options);
             }
             #include "moc_qabstractseries.cpp"
             #include "moc_qabstractseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterchart/qscatterseries.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "scatterchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "scatteranimation_p.h"
             #include "qchart_p.h"
             /*!
                 \class QScatterSeries
                 \brief The QScatterSeries class is used for making scatter charts.
                 \mainclass
                 The scatter data is displayed as a collection of points on the chart. Each point determines the position on the horizontal axis
                 and the vertical axis.
                 \image examples_scatterchart.png
                 Creating basic scatter chart is simple:
                 \code
                 QScatterSeries* series = new QScatterSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chart->addSeries(series);
                 \endcode
             */
             /*!
                 \qmlclass ScatterSeries QScatterSeries
                 \inherits XYSeries
                 The following QML shows how to create a chart with two simple scatter series:
                 \snippet ../demos/qmlchart/qml/qmlchart/View5.qml 1
                 \beginfloatleft
                 \image demos_qmlchart5.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \enum QScatterSeries::MarkerShape
                 This enum describes the shape used when rendering marker items.
                 \value MarkerShapeCircle
                 \value MarkerShapeRectangle
             */
             /*!
                 \property QScatterSeries::color
                 Fill (brush) color of the series. This is a convenience property for modifying the color of brush.
                 \sa QScatterSeries::brush()
             */
             /*!
                 \property QScatterSeries::borderColor
                 Line (pen) color of the series. This is a convenience property for modifying the color of pen.
                 \sa QScatterSeries::pen()
             */
             /*!
                 \qmlproperty color ScatterSeries::borderColor
                 Border (pen) color of the series.
             */
             /*!
                 \qmlproperty real ScatterSeries::borderWidth
                 The width of the border line. By default the width is 2.0.
             */
             /*!
                 \property QScatterSeries::markerShape
                 Defines the shape of the marker used to draw the points in the series. The default shape is MarkerShapeCircle.
             */
             /*!
                 \qmlproperty MarkerShape ScatterSeries::markerShape
                 Defines the shape of the marker used to draw the points in the series. One of ScatterSeries
                 ScatterSeries.MarkerShapeCircle or ScatterSeries.MarkerShapeRectangle.
                 The default shape is ScatterSeries.MarkerShapeCircle.
             */
             /*!
                 \property QScatterSeries::markerSize
                 Defines the size of the marker used to draw the points in the series. The default size is 15.0.
             */
             /*!
                 \qmlproperty real ScatterSeries::markerSize
                 Defines the size of the marker used to draw the points in the series. The default size is 15.0.
             */
             /*!
                 \fn void QScatterSeries::colorChanged(QColor color)
                 Signal is emitted when the fill (brush) color has changed to \a color.
             */
             /*!
                 \fn void QScatterSeries::borderColorChanged(QColor color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \qmlsignal ScatterSeries::borderColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
-                \fn QChartSeriesType QScatterSeries::type() const
+                \fn QAbstractSeries::SeriesType QScatterSeries::type() const
-                Returns QChartSeries::SeriesTypeScatter.
+                Returns QAbstractSeries::SeriesTypeScatter.
                 \sa QAbstractSeries, SeriesType
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QScatterSeries::QScatterSeries(QObject *parent)
                 : QXYSeries(*new QScatterSeriesPrivate(this), parent)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QScatterSeries::~QScatterSeries()
             {
                 Q_D(QScatterSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             QAbstractSeries::SeriesType QScatterSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeScatter;
             }
             /*!
                 Sets \a pen used for drawing points' border on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QScatterSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen != pen) {
                     bool emitColorChanged = d->m_pen.color() != pen.color();
                     d->m_pen = pen;
                     emit d->updated();
                     if (emitColorChanged)
                         emit borderColorChanged(pen.color());
                 }
             }
             /*!
                 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 QScatterSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QScatterSeries);
                 if (d->m_brush != brush) {
                     bool emitColorChanged = d->m_brush.color() != brush.color();
                     d->m_brush = brush;
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(brush.color());
                 }
             }
             void QScatterSeries::setColor(const QColor &color)
             {
                 QBrush b = brush();
                 if (b == QBrush())
                     b.setStyle(Qt::SolidPattern);
                 b.setColor(color);
                 setBrush(b);
             }
             QColor QScatterSeries::color() const
             {
                 return brush().color();
             }
             void QScatterSeries::setBorderColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QScatterSeries::borderColor() const
             {
                 return pen().color();
             }
             QScatterSeries::MarkerShape QScatterSeries::markerShape() const
             {
                 Q_D(const QScatterSeries);
                 return d->m_shape;
             }
             void QScatterSeries::setMarkerShape(MarkerShape shape)
             {
                 Q_D(QScatterSeries);
                 if (d->m_shape != shape) {
                     d->m_shape = shape;
                     emit d->updated();
                 }
             }
             qreal QScatterSeries::markerSize() const
             {
                 Q_D(const QScatterSeries);
                 return d->m_size;
             }
             void QScatterSeries::setMarkerSize(qreal size)
             {
                 Q_D(QScatterSeries);
                 if (!qFuzzyCompare(d->m_size, size)) {
                     d->m_size = size;
                     emit d->updated();
                 }
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QScatterSeriesPrivate::QScatterSeriesPrivate(QScatterSeries *q)
                 : QXYSeriesPrivate(q),
                   m_shape(QScatterSeries::MarkerShapeCircle),
                   m_size(15.0)
             {
             }
             void QScatterSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QScatterSeries);
                 ScatterChartItem *scatter = new ScatterChartItem(q,parent);
                 m_item.reset(scatter);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             void QScatterSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 Q_Q(QScatterSeries);
                 const QList<QColor> colors = theme->seriesColors();
                 const QList<QGradient> gradients = theme->seriesGradients();
                 if (forced || QChartPrivate::defaultPen() == m_pen) {
                     QPen pen;
                     pen.setColor(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0));
                     pen.setWidthF(2);
                     q->setPen(pen);
                 }
                 if (forced || QChartPrivate::defaultBrush() == m_brush) {
                     QBrush brush(colors.at(index % colors.size()));
                     q->setBrush(brush);
                 }
             }
             void QScatterSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 ScatterChartItem *item = static_cast<ScatterChartItem *>(m_item.data());
                 Q_ASSERT(item);
                 if (options.testFlag(QChart::SeriesAnimations))
                     item->setAnimation(new ScatterAnimation(item));
                 else
                     item->setAnimation(0);
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qhxymodelmapper.cpp +8 -3

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qhxymodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHXYModelMapper
                 \mainclass
                 Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
                 Horizontal model mapper is used to create a connection between QXYSeries and QAbstractItemModel derived model object.
                 It is possible to use both QAbstractItemModel and QXYSeries model API. QXYModelMapper makes sure that QXYSeries and the model are kept in sync.
                 Note: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
                 \qmlclass HXYModelMapper QHXYModelMapper
                 HXYModelMapper allows you to use your own QAbstractItemModel derived model with data in rows as a data source
                 for XYSeries based series. It is possible to use both QAbstractItemModel and XYSeries data API to manipulate data.
                 HXYModelMapper keeps the series and the model in sync.
             */
             /*!
                 \property QHXYModelMapper::series
                 \brief Defines the QXYSeries object that is used by the mapper.
                 All the data in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \qmlproperty XYSeries HXYModelMapper::series
                 Defines the XYSeries object that is used by the mapper. All the data in the series is discarded when it is set to
                 the mapper. When new series is specified the old series is disconnected (it preserves its data).
             */
             /*!
                 \property QHXYModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \qmlproperty SomeModel HXYModelMapper::model
                 The QAbstractItemModel based model that is used by the mapper. You need to implement the model and expose it to
                 QML as shown in \l {QML Custom Model} demo application. Note: the model has to support adding/removing rows/columns
                 and modifying the data of the cells.
             */
             /*!
                 \property QHXYModelMapper::xRow
-                \brief Defines which row of the model is kept in sync with the x values of the QXYSeries
+                \brief Defines which row of the model is kept in sync with the x values of the QXYSeries.
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int HXYModelMapper::xRow
                 Defines which row of the model is kept in sync with the x values of the series. Default value is -1 (invalid
                 mapping).
             */
             /*!
                 \property QHXYModelMapper::yRow
-                \brief Defines which row of the model is kept in sync with the  y values of the QXYSeries
+                \brief Defines which row of the model is kept in sync with the  y values of the QXYSeries.
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int HXYModelMapper::yRow
                 Defines which row of the model is kept in sync with the  y values of the series. Default value is -1
                 (invalid mapping).
             */
             /*!
                 \property QHXYModelMapper::firstColumn
                 \brief Defines which column of the model contains the data for the first point of the series.
                 Minimal and default value is: 0
             */
             /*!
                 \qmlproperty int HXYModelMapper::firstColumn
                 Defines which column of the model contains the data for the first point of the series.
                 The default value is 0.
             */
             /*!
                 \property QHXYModelMapper::columnCount
-                \brief Defines the number of columns of the model that are mapped as the data for series
+                \brief Defines the number of columns of the model that are mapped as the data for series.
                 Minimal and default value is: -1 (count limited by the number of columns in the model)
             */
             /*!
                 \qmlproperty int HXYModelMapper::columnCount
                 Defines the number of columns of the model that are mapped as the data for series. The default value is
                 -1 (count limited by the number of columns in the model)
             */
             /*!
                 \fn void QHXYModelMapper::seriesReplaced()
                 Emitted when the series to which mapper is connected to has changed.
             */
             /*!
                 \fn void QHXYModelMapper::modelReplaced()
                 Emitted when the model to which mapper is connected to has changed.
             */
             /*!
                 \fn void QHXYModelMapper::xRowChanged()
                 Emitted when the xRow has changed.
             */
             /*!
                 \fn void QHXYModelMapper::yRowChanged()
                 Emitted when the yRow has changed.
             */
             /*!
                 \fn void QHXYModelMapper::firstColumnChanged()
                 Emitted when the firstColumn has changed.
             */
             /*!
                 \fn void QHXYModelMapper::columnCountChanged()
                 Emitted when the columnCount has changed.
             */
             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QHXYModelMapper::QHXYModelMapper(QObject *parent) :
                 QXYModelMapper(parent)
             {
                 QXYModelMapper::setOrientation(Qt::Horizontal);
             }
             QAbstractItemModel *QHXYModelMapper::model() const
             {
                 return QXYModelMapper::model();
             }
             void QHXYModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model != QXYModelMapper::model()) {
                     QXYModelMapper::setModel(model);
                     emit modelReplaced();
                 }
             }
             QXYSeries *QHXYModelMapper::series() const
             {
                 return QXYModelMapper::series();
             }
             void QHXYModelMapper::setSeries(QXYSeries *series)
             {
                 if (series != QXYModelMapper::series()) {
                     QXYModelMapper::setSeries(series);
                     emit seriesReplaced();
                 }
             }
             int QHXYModelMapper::xRow() const
             {
                 return QXYModelMapper::xSection();
             }
             void QHXYModelMapper::setXRow(int xRow)
             {
                 if (xRow != xSection()) {
                     QXYModelMapper::setXSection(xRow);
                     emit xRowChanged();
                 }
             }
             int QHXYModelMapper::yRow() const
             {
                 return QXYModelMapper::ySection();
             }
             void QHXYModelMapper::setYRow(int yRow)
             {
                 if (yRow != ySection()) {
                     QXYModelMapper::setYSection(yRow);
                     emit yRowChanged();
                 }
             }
             int QHXYModelMapper::firstColumn() const
             {
                 return first();
             }
             void QHXYModelMapper::setFirstColumn(int firstColumn)
             {
                 if (firstColumn != first()) {
                     setFirst(firstColumn);
                     emit firstColumnChanged();
                 }
             }
             int QHXYModelMapper::columnCount() const
             {
                 return count();
             }
             void QHXYModelMapper::setColumnCount(int columnCount)
             {
                 if (columnCount != count()) {
                     setCount(columnCount);
                     emit columnCountChanged();
                 }
             }
             #include "moc_qhxymodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qvxymodelmapper.cpp +8 -3

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qvxymodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QVXYModelMapper
                 \mainclass
                 Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
                 Vertical model mapper is used to create a connection between QXYSeries and QAbstractItemModel derived model object.
                 It is possible to use both QAbstractItemModel and QXYSeries model API. QXYModelMapper makes sure that QXYSeries and the model are kept in sync.
                 Note: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
                 \qmlclass VXYModelMapper QHXYModelMapper
                 VXYModelMapper allows you to use your own QAbstractItemModel derived model with data in columns as a data source
                 for XYSeries based series. It is possible to use both QAbstractItemModel and XYSeries data API to manipulate data.
                 VYModelMapper keeps the series and the model in sync.
             */
             /*!
                 \property QVXYModelMapper::series
                 \brief Defines the QXYSeries object that is used by the mapper.
                 All the data in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \qmlproperty XYSeries VXYModelMapper::series
                 Defines the XYSeries object that is used by the mapper. All the data in the series is discarded when it is set to
                 the mapper. When new series is specified the old series is disconnected (it preserves its data).
             */
             /*!
                 \property QVXYModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \qmlproperty SomeModel VXYModelMapper::model
                 The QAbstractItemModel based model that is used by the mapper. You need to implement the model and expose it to
                 QML as shown in \l {QML Custom Model} demo application. Note: the model has to support adding/removing rows/columns
                 and modifying the data of the cells.
             */
             /*!
                 \property QVXYModelMapper::xColumn
-                \brief Defines which column of the model is kept in sync with the x values of QXYSeries
+                \brief Defines which column of the model is kept in sync with the x values of QXYSeries.
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int VXYModelMapper::xColumn
                 Defines which column of the model is kept in sync with the x values of the series. Default value is -1 (invalid
                 mapping).
             */
             /*!
                 \property QVXYModelMapper::yColumn
-                \brief Defines which column of the model is kept in sync with the y values of QXYSeries
+                \brief Defines which column of the model is kept in sync with the y values of QXYSeries.
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int VXYModelMapper::yColumn
                 Defines which column of the model is kept in sync with the y values of the series. Default value is -1 (invalid
                 mapping).
             */
             /*!
                 \property QVXYModelMapper::firstRow
                 \brief Defines which row of the model contains the data for the first point of the series.
                 Minimal and default value is: 0
             */
             /*!
                 \qmlproperty int VXYModelMapper::firstRow
                 Defines which row of the model contains the data for the first point of the series.
                 The default value is 0.
             */
             /*!
                 \property QVXYModelMapper::rowCount
-                \brief Defines the number of rows of the model that are mapped as the data for series
+                \brief Defines the number of rows of the model that are mapped as the data for series.
                 Minimal and default value is: -1 (count limited by the number of rows in the model)
             */
             /*!
                 \qmlproperty int VXYModelMapper::columnCount
                 Defines the number of rows of the model that are mapped as the data for series. The default value is
                 -1 (count limited by the number of rows in the model).
             */
             /*!
                 \fn void QVXYModelMapper::seriesReplaced()
                 Emitted when the series to which mapper is connected to has changed.
             */
             /*!
                 \fn void QVXYModelMapper::modelReplaced()
                 Emitted when the model to which mapper is connected to has changed.
             */
             /*!
                 \fn void QVXYModelMapper::xColumnChanged()
                 Emitted when the xColumn has changed.
             */
             /*!
                 \fn void QVXYModelMapper::yColumnChanged()
                 Emitted when the yColumn has changed.
             */
             /*!
                 \fn void QVXYModelMapper::firstRowChanged()
                 Emitted when the firstRow has changed.
             */
             /*!
                 \fn void QVXYModelMapper::rowCountChanged()
                 Emitted when the rowCount has changed.
             */
             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QVXYModelMapper::QVXYModelMapper(QObject *parent) :
                 QXYModelMapper(parent)
             {
                 QXYModelMapper::setOrientation(Qt::Vertical);
             }
             QAbstractItemModel *QVXYModelMapper::model() const
             {
                 return QXYModelMapper::model();
             }
             void QVXYModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model != QXYModelMapper::model()) {
                     QXYModelMapper::setModel(model);
                     emit modelReplaced();
                 }
             }
             QXYSeries *QVXYModelMapper::series() const
             {
                 return QXYModelMapper::series();
             }
             void QVXYModelMapper::setSeries(QXYSeries *series)
             {
                 if (series != QXYModelMapper::series()) {
                     QXYModelMapper::setSeries(series);
                     emit seriesReplaced();
                 }
             }
             int QVXYModelMapper::xColumn() const
             {
                 return QXYModelMapper::xSection();
             }
             void QVXYModelMapper::setXColumn(int xColumn)
             {
                 if (xColumn != xSection()) {
                     QXYModelMapper::setXSection(xColumn);
                     emit xColumnChanged();
                 }
             }
             int QVXYModelMapper::yColumn() const
             {
                 return QXYModelMapper::ySection();
             }
             void QVXYModelMapper::setYColumn(int yColumn)
             {
                 if (yColumn != ySection()) {
                     QXYModelMapper::setYSection(yColumn);
                     emit yColumnChanged();
                 }
             }
             int QVXYModelMapper::firstRow() const
             {
                 return first();
             }
             void QVXYModelMapper::setFirstRow(int firstRow)
             {
                 if (firstRow != first()) {
                     setFirst(firstRow);
                     emit firstRowChanged();
                 }
             }
             int QVXYModelMapper::rowCount() const
             {
                 return count();
             }
             void QVXYModelMapper::setRowCount(int rowCount)
             {
                 if (rowCount != count()) {
                     setCount(rowCount);
                     emit rowCountChanged();
                 }
             }
             #include "moc_qvxymodelmapper.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