HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2494:232715f311f8

Documentation updates...

Miikka Heikkinen -

r2494:232715f311f8

parent child

Context file:

r2494:232715f311f8

Expand all files

src/areachart/qareaseries.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 "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 counstucted wihtout a\ lowerSeries this is null.
+                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 counstucted wihtout a\ lowerSeries this is null.
+                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.
             */
             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);
                 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);
                 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_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);
                 QPen pen;
                 QBrush brush;
                 const QList<QGradient> gradients = theme->seriesGradients();
                 const QList<QColor> colors = theme->seriesColors();
                 if (forced || pen == m_pen) {
                     pen.setColor(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0));
                     pen.setWidthF(2);
                     q->setPen(pen);
                 }
                 if (forced || brush == 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/barcategoryaxis/qbarcategoryaxis.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 "qbarcategoryaxis.h"
             #include "qbarcategoryaxis_p.h"
             #include "chartbarcategoryaxisx_p.h"
             #include "chartbarcategoryaxisy_p.h"
             #include "abstractdomain_p.h"
             #include "qchart.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarCategoryAxis
                 \brief The QBarCategoryAxis class is used for manipulating chart's axis.
                 \mainclass
                 BarCategoryAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Categories are drawn between ticks. Note that you can use this also with lineseries too.
                 See the \l {Line and BarChart Example} {Line and BarChart Example} to learn how to do that.
                 Example code on how to use QBarCategoryAxis.
                 \code
                 QChartView *chartView = new QChartView;
                 QBarSeries *series = new QBarSeries;
                 // ...
                 chartView->chart()->addSeries(series);
                 chartView->chart()->createDefaultAxes();
                 QBarCategoryAxis *axisX = new QBarCategoryAxis;
                 QStringList categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
                 axisX->append(categories);
                 axisX->setRange("Feb", "May");
                 chartView->chart()->setAxisX(axisX, series);
                 \endcode
             */
             /*!
                 \qmlclass BarCategoryAxis QBarCategoryAxis
                 \inherits AbstractAxis
                 \brief The Axis element is used for manipulating chart's axes.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 Categories are drawn between ticks. Note that you can use this also with lineseries too.
                 To access BarCategoryAxis you can use ChartView API. For example:
                 \code
                     ChartView {
                         BarCategoryAxis {
                             id: categoryAxis
                             categories: ["Jan", "Feb", "Mar", "Apr", "May", "Jun" ]
                         }
                     // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QBarCategoryAxis::categories
               Defines the categories of axis
             */
             /*!
               \qmlproperty QStringList BarCategoryAxis::categories
               Defines the categories of axis
             */
             /*!
               \property QBarCategoryAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \qmlproperty string BarCategoryAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \property QBarCategoryAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \qmlproperty string BarCategoryAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \property QBarCategoryAxis::count
               The count of categories.
             */
             /*!
               \qmlproperty int BarCategoryAxis::count
               The count of categories.
             */
             /*!
               \fn void QBarCategoryAxis::categoriesChanged()
               Axis emits signal when the categories of the axis have changed.
             */
             /*!
               \fn void QBarCategoryAxis::minChanged(const QString &min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \qmlsignal BarCategoryAxis::onMinChanged(const QString &min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QBarCategoryAxis::maxChanged(const QString &max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \qmlsignal BarCategoryAxis::onMaxChanged(const QString &max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QBarCategoryAxis::countChanged()
               Axis emits signal when the count of categories has changed.
             */
             /*!
               \qmlsignal BarCategoryAxis::onCountChanged()
               Axis emits signal when the count of categories has changed.
             */
             /*!
               \fn void QBarCategoryAxis::rangeChanged(const QString &min, const QString &max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QBarCategoryAxis::QBarCategoryAxis(QObject *parent):
                 QAbstractAxis(*new QBarCategoryAxisPrivate(this), parent)
             {
             }
             /*!
                 Destroys the object
             */
             QBarCategoryAxis::~QBarCategoryAxis()
             {
                 Q_D(QBarCategoryAxis);
                 if (d->m_chart)
                     d->m_chart->removeAxis(this);
             }
             /*!
                 \internal
             */
             QBarCategoryAxis::QBarCategoryAxis(QBarCategoryAxisPrivate &d, QObject *parent)
                 : QAbstractAxis(d, parent)
             {
             }
             /*!
                 Appends \a categories to axis. A maximum of the axis will be changed to last category in \a categories.
                 If there were no categories previously defined, minimum of axis will be also changed to first category in \a categories.
                 A category has to be valid QStrings and can not be duplicated. Duplicated categories will not be appended.
             */
             void QBarCategoryAxis::append(const QStringList &categories)
             {
                 if (categories.isEmpty())
                     return;
                 Q_D(QBarCategoryAxis);
                 int count = d->m_categories.count();
                 foreach(QString category, categories) {
                     if (!d->m_categories.contains(category) && !category.isNull()) {
                         d->m_categories.append(category);
                     }
                 }
                 if (d->m_categories.count() == count)
                     return;
                 if (count == 0)
                     setRange(d->m_categories.first(), d->m_categories.last());
                 else
                     setRange(d->m_minCategory, d->m_categories.last());
                 emit categoriesChanged();
                 emit countChanged();
             }
             /*!
                 Appends \a category to axis. A maximum of the axis will be changed to last \a category.
                 If there were no categories previously defined, minimum of axis will be also changed to \a category.
                 A \a category has to be valid QStrings and can not be duplicated. Duplicated categories will not be appended.
             */
             void QBarCategoryAxis::append(const QString &category)
             {
                 Q_D(QBarCategoryAxis);
                 int count = d->m_categories.count();
                 if (!d->m_categories.contains(category) && !category.isNull())
                     d->m_categories.append(category);
                 if (d->m_categories.count() == count)
                     return;
                 if (count == 0)
                     setRange(d->m_categories.last(), d->m_categories.last());
                 else
                     setRange(d->m_minCategory, d->m_categories.last());
                 emit categoriesChanged();
                 emit countChanged();
             }
             /*!
                 Removes \a category from axis. Removing category which is currently maximum or minimum
                 will affect the axis range.
             */
             void QBarCategoryAxis::remove(const QString &category)
             {
                 Q_D(QBarCategoryAxis);
                 if (d->m_categories.contains(category)) {
                     d->m_categories.removeAt(d->m_categories.indexOf(category));
                     if (!d->m_categories.isEmpty()) {
                         if (d->m_minCategory == category) {
                             setRange(d->m_categories.first(), d->m_maxCategory);
                         } else if (d->m_maxCategory == category) {
                             setRange(d->m_minCategory, d->m_categories.last());
                         } else {
                             d->updateCategoryDomain();
                             //TODO:: d->emitUpdated();
                         }
                     } else {
                         setRange(QString::null, QString::null);
                     }
                     emit categoriesChanged();
                     emit countChanged();
                 }
             }
             /*!
                 Inserts \a category to axis at \a index. A \a category has to be valid QStrings and can not be duplicated.
                 If \a category is prepended or appended to categories, minimum and maximum of axis is updated accordingly.
             */
             void QBarCategoryAxis::insert(int index, const QString &category)
             {
                 Q_D(QBarCategoryAxis);
                 int count = d->m_categories.count();
                 if (!d->m_categories.contains(category) && !category.isNull())
                     d->m_categories.insert(index, category);
                 if (d->m_categories.count() == count)
                     return;
                 if (count == 0) {
                     setRange(d->m_categories.first(), d->m_categories.first());
                 } else if (index == 0) {
                     setRange(d->m_categories.first(), d->m_maxCategory);
                 } else if (index == count) {
                     setRange(d->m_minCategory, d->m_categories.last());
                 } else {
                     d->updateCategoryDomain();
                     //TODO:: d->emitUpdated();
                 }
                 emit categoriesChanged();
                 emit countChanged();
             }
             /*!
-                Replaces \a oldCategory with \a newCategory. If \a oldCategory does not exits on the axis nothing is done.
+                Replaces \a oldCategory with \a newCategory. If \a oldCategory does not exist on the axis nothing is done.
                 A \a newCategory has to be valid QStrings and can not be duplicated. In case of replacing minimum or maximum category,
                 minimum and maximum of axis is updated accordingly.
             */
             void QBarCategoryAxis::replace(const QString &oldCategory, const QString &newCategory)
             {
                 Q_D(QBarCategoryAxis);
                 int pos = d->m_categories.indexOf(oldCategory);
                 if (pos != -1 && !d->m_categories.contains(newCategory) && !newCategory.isNull()) {
                     d->m_categories.replace(pos, newCategory);
                     if (d->m_minCategory == oldCategory) {
                         setRange(newCategory, d->m_maxCategory);
                     } else if (d->m_maxCategory == oldCategory) {
                         setRange(d->m_minCategory, newCategory);
                     } else {
                         //TODO:: d->emitUpdated();
                     }
                     emit categoriesChanged();
                     emit countChanged();
                 }
             }
             /*!
               Removes all categories. Sets the maximum and minimum of the axis's range to QString::null.
              */
             void QBarCategoryAxis::clear()
             {
                 Q_D(QBarCategoryAxis);
                 d->m_categories.clear();
                 setRange(QString::null, QString::null);
                 emit categoriesChanged();
                 emit countChanged();
             }
             /*!
                Set \a categories and discards the old ones, range of axis is adjusted to match first and last category in \a categories.
                A category has to be valid QStrings and can not be duplicated.
             */
             void QBarCategoryAxis::setCategories(const QStringList &categories)
             {
                 Q_D(QBarCategoryAxis);
                 d->m_categories.clear();
                 d->m_minCategory = QString::null;
                 d->m_maxCategory = QString::null;
                 d->m_min = 0;
                 d->m_max = 0;
                 d->m_count = 0;
                 append(categories);
             }
             /*!
                 Returns categories
             */
             QStringList QBarCategoryAxis::categories()
             {
                 Q_D(QBarCategoryAxis);
                 return d->m_categories;
             }
             /*!
               Returns number of categories.
              */
             int QBarCategoryAxis::count() const
             {
                 Q_D(const QBarCategoryAxis);
                 return d->m_categories.count();
             }
             /*!
                 Returns category at \a index. Index must be valid.
             */
             QString QBarCategoryAxis::at(int index) const
             {
                 Q_D(const QBarCategoryAxis);
                 return d->m_categories.at(index);
             }
             /*!
                 Sets minimum category to \a min.
             */
             void QBarCategoryAxis::setMin(const QString &min)
             {
                 Q_D(QBarCategoryAxis);
                 d->setRange(min, d->m_maxCategory);
             }
             /*!
                 Returns minimum category.
             */
             QString QBarCategoryAxis::min() const
             {
                 Q_D(const QBarCategoryAxis);
                 return d->m_minCategory;
             }
             /*!
                 Sets maximum category to \a max.
             */
             void QBarCategoryAxis::setMax(const QString &max)
             {
                 Q_D(QBarCategoryAxis);
                 d->setRange(d->m_minCategory, max);
             }
             /*!
                 Returns maximum category
             */
             QString QBarCategoryAxis::max() const
             {
                 Q_D(const QBarCategoryAxis);
                 return d->m_maxCategory;
             }
             /*!
                 Sets range from \a minCategory to \a maxCategory
             */
             void QBarCategoryAxis::setRange(const QString &minCategory, const QString &maxCategory)
             {
                 Q_D(QBarCategoryAxis);
                 d->setRange(minCategory,maxCategory);
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QBarCategoryAxis::type() const
             {
                 return AxisTypeBarCategory;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarCategoryAxisPrivate::QBarCategoryAxisPrivate(QBarCategoryAxis *q)
                 : QAbstractAxisPrivate(q),
                   m_min(0.0),
                   m_max(0.0),
                   m_count(0)
             {
             }
             QBarCategoryAxisPrivate::~QBarCategoryAxisPrivate()
             {
             }
             void QBarCategoryAxisPrivate::setMin(const QVariant &min)
             {
                 setRange(min, m_maxCategory);
             }
             void QBarCategoryAxisPrivate::setMax(const QVariant &max)
             {
                 setRange(m_minCategory, max);
             }
             void QBarCategoryAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 QString value1 = min.toString();
                 QString value2 = max.toString();
                 setRange(value1, value2);
             }
             void QBarCategoryAxisPrivate::setRange(qreal min, qreal max)
             {
                 Q_Q(QBarCategoryAxis);
                 bool categoryChanged = false;
                 bool changed = false;
                 if (min > max)
                     return;
                 if (!qFuzzyIsNull(m_min - min)) {
                     m_min = min;
                     changed = true;
                     int imin = m_min + 0.5;
                     if (imin >= 0 && imin < m_categories.count()) {
                         QString minCategory = m_categories.at(imin);
                         if (m_minCategory != minCategory && !minCategory.isEmpty()) {
                             m_minCategory = minCategory;
                             categoryChanged = true;
                             emit q->minChanged(minCategory);
                         }
                     }
                 }
                 if (!qFuzzyIsNull(m_max - max)) {
                     m_max = max;
                     changed = true;
                     int imax = m_max - 0.5;
                     if (imax >= 0 && imax < m_categories.count()) {
                         QString maxCategory = m_categories.at(imax);
                         if (m_maxCategory != maxCategory && !maxCategory.isEmpty()) {
                             m_maxCategory = maxCategory;
                             categoryChanged = true;
                             emit q->maxChanged(maxCategory);
                         }
                     }
                 }
                 if (categoryChanged){
                     emit q->rangeChanged(m_minCategory, m_maxCategory);
                 }
                 if (changed) {
                     emit rangeChanged(m_min,m_max);
                 }
             }
             void  QBarCategoryAxisPrivate::setRange(const QString &minCategory, const QString &maxCategory)
             {
             	Q_Q(QBarCategoryAxis);
                 bool changed = false;
                 //special case in case or clearing all categories
                 if (minCategory.isNull() && maxCategory.isNull()) {
                     m_minCategory = minCategory;
                     m_maxCategory = maxCategory;
                     m_min = 0;
                     m_max = 0;
                     m_count = 0;
                     emit q->minChanged(minCategory);
                     emit q->maxChanged(maxCategory);
                     emit q->rangeChanged(m_minCategory, m_maxCategory);
                     emit rangeChanged(m_min,m_max);
                 }
                 if (m_categories.indexOf(maxCategory) < m_categories.indexOf(minCategory))
                     return;
                 if (!minCategory.isEmpty() && m_minCategory != minCategory && m_categories.contains(minCategory)) {
                     m_minCategory = minCategory;
                     m_min = m_categories.indexOf(m_minCategory) - 0.5;
                     changed = true;
                     emit q->minChanged(minCategory);
                 }
                 if (!maxCategory.isEmpty() && m_maxCategory != maxCategory && m_categories.contains(maxCategory)) {
                     m_maxCategory = maxCategory;
                     m_max = m_categories.indexOf(m_maxCategory) + 0.5;
                     changed = true;
                     emit q->maxChanged(maxCategory);
                 }
                 if (changed) {
                     m_count = m_max - m_min;
                     emit q->rangeChanged(m_minCategory, m_maxCategory);
                     emit rangeChanged(m_min,m_max);
                 }
             }
             void QBarCategoryAxisPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QBarCategoryAxis);
                 ChartAxisElement* axis(0);
                 if (orientation() == Qt::Vertical)
                     axis = new ChartBarCategoryAxisY(q,parent);
                 if (orientation() == Qt::Horizontal)
                     axis = new ChartBarCategoryAxisX(q,parent);
                 m_item.reset(axis);
                 QAbstractAxisPrivate::initializeGraphics(parent);
             }
             void QBarCategoryAxisPrivate::updateCategoryDomain()
             {
                 m_min = m_categories.indexOf(m_minCategory) - 0.5;
                 m_max = m_categories.indexOf(m_maxCategory) + 0.5;
                 m_count = m_max - m_min;
             }
             void QBarCategoryAxisPrivate::initializeDomain(AbstractDomain *domain)
             {
                 Q_Q(QBarCategoryAxis);
                 if (m_max == m_min) {
                     int min;
                     int max;
                     if (orientation() == Qt::Vertical) {
                         min = domain->minY() + 0.5;
                         max = domain->maxY() - 0.5;
                     } else {
                         min = domain->minX() + 0.5;
                         max = domain->maxX() - 0.5;
                     }
                     if (min > 0 && min < m_categories.count() && max > 0 && max < m_categories.count())
                         q->setRange(m_categories.at(min), m_categories.at(max));
                 } else {
                     if (orientation() == Qt::Vertical)
                         domain->setRangeY(m_min, m_max);
                     else
                         domain->setRangeX(m_min, m_max);
                 }
             }
             #include "moc_qbarcategoryaxis.cpp"
             #include "moc_qbarcategoryaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/datetimeaxis/qdatetimeaxis.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 "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
+                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 QLineSeries, QSplineSeries or QScatterSeries.
+                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
                 \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 +8 -8

             /****************************************************************************
             **
             ** 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 LogValuesAxis QLogValueAxis
+                \qmlclass LogValueAxis QLogValueAxis
                 \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 LogValuesAxis::min
+              \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 LogValuesAxis::max
+              \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 LogValuesAxis::base
+              \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 LogValuesAxis::labelFormat
+              \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 LogValuesAxis::onMinChanged(qreal min)
+              \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 LogValuesAxis::onMaxChanged(qreal max)
+              \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 LogValuesAxis::baseChanged(qreal base)
+              \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 +11 -19

             /****************************************************************************
             **
             ** 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"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractAxis
                 \brief The QAbstractAxis class is used for manipulating chart's axis.
                 \mainclass
-                There is only one x Axis visible at the time, however there can be multiple y axes.
+                Each series can be bound to one or more horizontal and vertical axes, but mixing axis types
-                Each chart series can be bound to exactly one Y axis and the shared common X axis.
+                that would result in different domains is not supported, such as specifying
-                Axis can be setup to show axis line with tick marks, grid lines and shades.
+                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 Axis element is used for manipulating chart's axes
+                \brief The AbstractAxis is a base element used for specialized axis elements
-                There is only one x Axis visible at the time, however there can be multiple y axes on a ChartView.
+                Each series can be bound to only one horizontal and vertical axis.
-                Each chart series can be bound to exactly one Y axis and the shared common X axis.
-                Axis can be setup to show axis line with tick marks, grid lines and shades.
-                To access Axes you can use ChartView API. For example:
+                Properties and visibility of various axis elements such as axis line, title, labels, grid lines,
-                \code
+                and shades can be individually controlled.
-                    ChartView {
-                        axisX.min: 0
-                        axisX.max: 3
-                        axisX.ticksCount: 4
-                        axisY.min: 0
-                        axisY.max: 4
-                        // Add a few series...
-                \endcode
             */
             /*!
                 \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 Chart/Series.
+              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
             {
                 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 d_ptr->m_axisPen.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
             {
                 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
             {
                 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
             {
                 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
             {
                 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 d_ptr->m_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
             {
                 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
             {
                 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
             {
                 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
             {
                 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
             {
                 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 d_ptr->m_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 d_ptr->m_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_gridLineVisible(true),
                   m_labelsVisible(true),
                   m_labelsAngle(0),
                   m_titleVisible(true),
                   m_shadesVisible(false),
                   m_shadesBrush(Qt::SolidPattern),
                   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)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 bool axisX = m_orientation == Qt::Horizontal;
                 //TODO: introduce axis brush
                 if (m_visible) {
                     if (m_arrowVisible) {
                         if (forced || pen == m_axisPen) {
                             q_ptr->setLinePen(theme->axisLinePen());
                         }
                     }
                     if (m_gridLineVisible) {
                         if (forced || pen == m_gridLinePen) {
                             q_ptr->setGridLinePen(theme->girdLinePen());
                         }
                     }
                     if (m_labelsVisible) {
                         if (forced || brush == m_labelsBrush){
                             q_ptr->setLabelsBrush(theme->labelBrush());
                         }
                         if (forced || pen == m_labelsPen){
                             q_ptr->setLabelsPen(Qt::NoPen);// NoPen for performance reasons
                         }
                         if (forced || font == m_labelsFont){
                             q_ptr->setLabelsFont(theme->labelFont());
                         }
                     }
                     if (m_titleVisible) {
                         if (forced || brush == m_titleBrush){
                             q_ptr->setTitleBrush(theme->labelBrush());
                         }
                         if (forced || pen == m_titlePen){
                             q_ptr->setTitlePen(Qt::NoPen);// Noen for performance reasons
                         }
                         if (forced || font == m_titleFont){
                             QFont font(m_labelsFont);
                             font.setBold(true);
                             q_ptr->setTitleFont(font);
                         }
                     }
                     if (forced || m_shadesVisible) {
                         if (forced || brush == m_shadesBrush){
                             q_ptr->setShadesBrush(theme->backgroundShadesBrush());
                         }
                         if (forced || pen == m_shadesPen){
                             q_ptr->setShadesPen(theme->backgroundShadesPen());
                         }
                         if (forced && (theme->backgroundShades() == ChartTheme::BackgroundShadesBoth
                                 || (theme->backgroundShades() == ChartTheme::BackgroundShadesVertical && axisX)
                                 || (theme->backgroundShades() == ChartTheme::BackgroundShadesHorizontal && !axisX))) {
                              q_ptr->setShadesVisible(true);
                         }
                     }
                 }
             }
             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/axis/valueaxis/qvalueaxis.cpp +3 -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 "qvalueaxis.h"
             #include "qvalueaxis_p.h"
             #include "chartvalueaxisx_p.h"
             #include "chartvalueaxisy_p.h"
             #include "abstractdomain_p.h"
             #include "polarchartvalueaxisangular_p.h"
             #include "polarchartvalueaxisradial_p.h"
             #include "chartdataset_p.h"
             #include "chartpresenter_p.h"
             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QValueAxis
                 \brief The QValueAxis class is used for manipulating chart's axis.
                 \mainclass
                 ValueAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Values of axis are drawn to position of ticks.
                 Example code on how to use QValueAxis.
                 \code
                 QChartView *chartView = new QChartView;
                 QLineSeries *series = new QLineSeries;
                 // ...
                 chartView->chart()->addSeries(series);
                 QValueAxis *axisX = new QValueAxis;
                 axisX->setRange(10, 20.5);
                 axisX->setTickCount(10);
                 axisX->setLabelFormat("%.2f");
                 chartView->chart()->setAxisX(axisX, series);
                 \endcode
             */
             /*!
                 \qmlclass ValueAxis QValueAxis
                 \inherits AbstractAxis
                 \brief The ValueAxis element is used for manipulating chart's axes
                 ValueAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Values of axis are drawn to position of ticks
-                To access Axes you can use ChartView API. For example:
+                Example about using ValueAxis:
                 \code
                     ChartView {
                         ValueAxis {
                             id: xAxis
                             min: 0
                             max: 10
                         }
                     // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QValueAxis::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 ValueAxis::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 QValueAxis::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 ValueAxis::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.
             */
             /*!
               \property QValueAxis::tickCount
               Defines the number of ticks on the axis. This indicates how many grid lines are draw on the chart.
               The default value is 5, and it can not be below 2.
             */
             /*!
               \qmlproperty real ValueAxis::tickCount
                Defines the number of ticks on the axis. This indicates how many grid lines are draw on the chart.
                The default value is 5, and it can not be below 2.
             */
             /*!
               \property QValueAxis::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 ValueAxis::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 QValueAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \qmlsignal ValueAxis::onMinChanged(real min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QValueAxis::maxChanged(qreal max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \qmlsignal ValueAxis::onMaxChanged(real max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QValueAxis::tickCountChanged(int tickCount)
-              Axis emits signal when \a tickCount number on axis have changed.
+              Axis emits signal when \a tickCount of axis has changed.
             */
             /*!
               \qmlsignal ValueAxis::tickCountChanged(int tickCount)
-              Axis emits signal when \a tickCount number on axis have changed.
+              Axis emits signal when \a tickCount of axis has changed.
             */
             /*!
               \fn void QValueAxis::rangeChanged(qreal min, qreal max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
               \fn void QValueAxis::labelFormatChanged(const QString &format)
               Axis emits signal when \a format of axis labels has changed.
             */
             /*!
               \qmlsignal ValueAxis::labelFormatChanged(const QString &format)
               Axis emits signal when \a format of axis labels has changed.
             */
             /*!
               \property QValueAxis::niceNumbersEnabled
               \obsolete
               Using this function can lead to unexpected behavior. Use applyNiceNumbers() instead.
             */
             /*!
               \qmlproperty bool ValueAxis::niceNumbersEnabled
               \obsolete
               Using this function can lead to unexpected behavior. Use applyNiceNumbers() instead.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QValueAxis::QValueAxis(QObject *parent) :
                 QAbstractAxis(*new QValueAxisPrivate(this), parent)
             {
             }
             /*!
                 \internal
             */
             QValueAxis::QValueAxis(QValueAxisPrivate &d, QObject *parent)
                 : QAbstractAxis(d, parent)
             {
             }
             /*!
                 Destroys the object
             */
             QValueAxis::~QValueAxis()
             {
                 Q_D(QValueAxis);
                 if (d->m_chart)
                     d->m_chart->removeAxis(this);
             }
             void QValueAxis::setMin(qreal min)
             {
                 Q_D(QValueAxis);
                 setRange(min, qMax(d->m_max, min));
             }
             qreal QValueAxis::min() const
             {
                 Q_D(const QValueAxis);
                 return d->m_min;
             }
             void QValueAxis::setMax(qreal max)
             {
                 Q_D(QValueAxis);
                 setRange(qMin(d->m_min, max), max);
             }
             qreal QValueAxis::max() const
             {
                 Q_D(const QValueAxis);
                 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 QValueAxis::setRange(qreal min, qreal max)
             {
                 Q_D(QValueAxis);
                 d->setRange(min,max);
             }
             void QValueAxis::setTickCount(int count)
             {
                 Q_D(QValueAxis);
                 if (d->m_tickCount != count && count >= 2) {
                     d->m_tickCount = count;
                     emit tickCountChanged(count);
                 }
             }
             int QValueAxis::tickCount() const
             {
                 Q_D(const QValueAxis);
                 return d->m_tickCount;
             }
             void QValueAxis::setNiceNumbersEnabled(bool enable)
             {
                 Q_D(QValueAxis);
                 qWarning()<<"This function is depreciated, it can lead to unexpected behavior.Use applyNiceNumbers(). ";
                 if(enable) {
                     QObject::connect(this,SIGNAL(rangeChanged(qreal,qreal)),this,SLOT(applyNiceNumbers()));
                     QObject::connect(this,SIGNAL(tickCountChanged(int)),this,SLOT(applyNiceNumbers()));
                     applyNiceNumbers();
                 }
                 else {
                     QObject::disconnect(this,SIGNAL(rangeChanged(qreal,qreal)),this,SLOT(applyNiceNumbers()));
                     QObject::disconnect(this,SIGNAL(tickCountChanged(int)),this,SLOT(applyNiceNumbers()));
                 }
                 d->m_niceNumbersEnabled=enable;
             }
             bool QValueAxis::niceNumbersEnabled() const
             {
                 Q_D(const QValueAxis);
                 qWarning()<<"This function is depreciated.Use applyNiceNumbers().";
                 return d->m_niceNumbersEnabled;
             }
             void QValueAxis::setLabelFormat(const QString &format)
             {
                 Q_D(QValueAxis);
                 d->m_format = format;
                 emit labelFormatChanged(format);
             }
             QString QValueAxis::labelFormat() const
             {
                 Q_D(const QValueAxis);
                 return d->m_format;
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QValueAxis::type() const
             {
                 return AxisTypeValue;
             }
             /*!
                 This method modifies range and number of ticks on the axis to look "nice". Algorithm considers numbers that
                 can be expressed as form of 1*10^n, 2* 10^n or 5*10^n as a nice numbers. These numbers are used for spacing the ticks.
                 This method will modify the current range and number of ticks.
                 \sa setRange(), setTickCount()
             */
             void QValueAxis::applyNiceNumbers()
             {
                 Q_D(QValueAxis);
                 if(d->m_applying) return;
                 qreal min = d->m_min;
                 qreal max = d->m_max;
                 int ticks = d->m_tickCount;
                 AbstractDomain::looseNiceNumbers(min,max,ticks);
                 d->m_applying=true;
                 d->setRange(min,max);
                 setTickCount(ticks);
                 d->m_applying=false;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QValueAxisPrivate::QValueAxisPrivate(QValueAxis *q)
                 : QAbstractAxisPrivate(q),
                   m_min(0),
                   m_max(0),
                   m_tickCount(5),
                   m_format(QString::null),
                   m_applying(false),
                   m_niceNumbersEnabled(false)
             {
             }
             QValueAxisPrivate::~QValueAxisPrivate()
             {
             }
             void QValueAxisPrivate::setMin(const QVariant &min)
             {
                 Q_Q(QValueAxis);
                 bool ok;
                 qreal value = min.toReal(&ok);
                 if (ok)
                     q->setMin(value);
             }
             void QValueAxisPrivate::setMax(const QVariant &max)
             {
                 Q_Q(QValueAxis);
                 bool ok;
                 qreal value = max.toReal(&ok);
                 if (ok)
                     q->setMax(value);
             }
             void QValueAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QValueAxis);
                 bool ok1;
                 bool ok2;
                 qreal value1 = min.toReal(&ok1);
                 qreal value2 = max.toReal(&ok2);
                 if (ok1 && ok2)
                     q->setRange(value1, value2);
             }
             void QValueAxisPrivate::setRange(qreal min, qreal max)
             {
             	Q_Q(QValueAxis);
                 bool changed = false;
                 if (min > max)
                     return;
                 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 QValueAxisPrivate::initializeGraphics(QGraphicsItem *parent)
             {
                 Q_Q(QValueAxis);
                 ChartAxisElement *axis(0);
                 if (m_chart->chartType() == QChart::ChartTypeCartesian) {
                     if (orientation() == Qt::Vertical)
                         axis = new ChartValueAxisY(q,parent);
                     if (orientation() == Qt::Horizontal)
                         axis = new ChartValueAxisX(q,parent);
                 }
                 if (m_chart->chartType() == QChart::ChartTypePolar) {
                     if (orientation() == Qt::Vertical)
                         axis = new PolarChartValueAxisRadial(q, parent);
                     if (orientation() == Qt::Horizontal)
                         axis = new PolarChartValueAxisAngular(q, parent);
                 }
                 m_item.reset(axis);
                 QAbstractAxisPrivate::initializeGraphics(parent);
             }
             void QValueAxisPrivate::initializeDomain(AbstractDomain *domain)
             {
                 if (orientation() == Qt::Vertical) {
                     if (!qFuzzyIsNull(m_max - m_min))
                         domain->setRangeY(m_min, m_max);
                     else
                         setRange(domain->minY(), domain->maxY());
                 }
                 if (orientation() == Qt::Horizontal) {
                     if (!qFuzzyIsNull(m_max - m_min))
                         domain->setRangeX(m_min, m_max);
                     else
                         setRange(domain->minX(), domain->maxX());
                 }
             }
             #include "moc_qvalueaxis.cpp"
             #include "moc_qvalueaxis_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
                 \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
+                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 +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 "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
                 \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.
             */
             QAbstractSeries::SeriesType QHorizontalPercentBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeHorizontalPercentBar;
             }
             /*!
-                Destructor
+                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 +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 "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
                 \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
+                Destructor.
                 Removes series from chart.
             */
             QHorizontalStackedBarSeries::~QHorizontalStackedBarSeries()
             {
                 Q_D(QHorizontalStackedBarSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
                 Returns QChartSeries::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/qbarset.cpp +6 -6

             /****************************************************************************
             **
             ** 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"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSet
                 \brief Building block for different bar charts
                 QBarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 \mainclass
                 \sa 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.
             */
             /*!
                 \qmlproperty string BarSet::label
                 Defines the label of the barSet.
             */
             /*!
                 \property QBarSet::pen
                 \brief Defines the pen used by the barSet.
             */
             /*!
                 \property QBarSet::brush
                 \brief Defines the brush used by the barSet.
             */
             /*!
                 \property QBarSet::labelBrush
                 \brief Defines the brush used by the barSet's label.
             */
             /*!
                 \property QBarSet::labelFont
                 \brief Defines the font used by the barSet's label.
             */
             /*!
                 \qmlproperty Font BarSet::labelFont
                 Defines the font used by the barSet's label.
                 See the \l {Font} {QML Font Element} for detailed documentation.
             */
             /*!
                 \property QBarSet::color
                 The fill (brush) color of the bar set.
             */
             /*!
                 \qmlproperty color BarSet::color
                 The fill (brush) color of the bar set.
             */
             /*!
                 \property QBarSet::borderColor
                 The line (pen) color of the bar set.
             */
             /*!
                 \qmlproperty color BarSet::borderColor
                 The line (pen) color of the bar set.
             */
             /*!
                 \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.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \fn void QBarSet::hovered(bool status)
                 The signal is emitted if mouse is hovered on top of barset.
                 Parameter \a status is true, if mouse entered on top of barset, false if mouse left from top of barset.
             */
             /*!
                 \fn void QBarSet::labelChanged()
                 This signal is emitted when the label of the barSet has changed.
                 \sa label
             */
             /*!
                 \qmlsignal BarSet::onLabelChanged()
                 This signal is emitted when the label of the barSet has changed.
             */
             /*!
                 \fn void QBarSet::penChanged()
                 This signal is emitted when the pen of the barSet has changed.
                 \sa pen
             */
             /*!
                 \fn void QBarSet::brushChanged()
                 This signal is emitted when the brush of the barSet has changed.
                 \sa brush
             */
             /*!
                 \fn void QBarSet::labelBrushChanged()
                 This signal is emitted when the brush of the barSet's label has changed.
                 \sa labelBrush
             */
             /*!
                 \fn void QBarSet::labelFontChanged()
                 This signal is emitted when the font of the barSet's label has changed.
                 \sa labelBrush
             */
             /*!
                 \fn void QBarSet::colorChanged(QColor)
                 This signal is emitted when the fill (brush) color of the set has changed to \a color.
             */
             /*!
                 \qmlsignal BarSet::onColorChanged(color color)
                 This signal is emitted when the fill (brush) color of the set has changed to \a color.
             */
             /*!
                 \fn void QBarSet::borderColorChanged(QColor)
                 This signal is emitted when the line (pen) color of the set has changed to \a color.
             */
             /*!
                 \qmlsignal BarSet::onBorderColorChanged(color color)
                 This signal is emitted when the line (pen) color of the set has changed to \a color.
             */
             /*!
                 \fn void QBarSet::labelColorChanged(QColor)
                 This signal is emitted when the text (label) color of the set has changed to \a color.
             */
             /*!
                 \qmlsignal BarSet::onLabelColorChanged(color color)
                 This signal is emitted when the text (label) color of the set has changed to \a color.
             */
             /*!
                 \fn void QBarSet::valuesAdded(int index, int count)
                 This signal is emitted when new values have been added to the set.
                 Parameter \a index indicates the position of the first inserted value.
-                Parameter \a count is the number of iserted values.
+                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 iserted values.
+                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
             */
             /*!
                 \qmlproperty QVariantList BarSet::values
                 The values of the barset. You can set either a list of reals or a list of points as values. If you set a list of
                 reals as values, the values are automatically completed to points by using the index of a value as it's
                 x-coordinate. For example:
                 \code
                     myBarSet1.values = [0, 5, 1, 5];
                     myBarSet2.values = [Qt.point(0, 1), Qt.point(1, 5), Qt.point(2.2, 4.3)];
                 \endcode
             */
             /*!
-                Constructs QBarSet with a label of \a label and with parent of \a parent
+                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 barset.
             */
             QBarSet::~QBarSet()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
                 Sets new \a label for set.
             */
             void QBarSet::setLabel(const QString label)
             {
                 d_ptr->m_label = label;
                 emit labelChanged();
             }
             /*!
                 Returns label of the set.
             */
             QString QBarSet::label() const
             {
                 return d_ptr->m_label;
             }
             /*!
                 Appends 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
                 \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 postion index + 1
+                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
+                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.
             */
             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
             {
                 return d_ptr->m_pen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
             void QBarSet::setBrush(const QBrush &brush)
             {
                 if (d_ptr->m_brush != brush) {
                     d_ptr->m_brush = brush;
                     emit d_ptr->updatedBars();
                     emit brushChanged();
                 }
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush() const
             {
                 return d_ptr->m_brush;
             }
             /*!
                 Sets \a brush of the values that are drawn on top of this barset
             */
             void QBarSet::setLabelBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelBrush != brush) {
                     d_ptr->m_labelBrush = brush;
                     emit d_ptr->updatedBars();
                     emit labelBrushChanged();
                 }
             }
             /*!
                 Returns brush of the values that are drawn on top of this barset
             */
             QBrush QBarSet::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             /*!
                 Sets the \a font for values that are drawn on top of this barset
             */
             void QBarSet::setLabelFont(const QFont &font)
             {
                 if (d_ptr->m_labelFont != font) {
                     d_ptr->m_labelFont = font;
                     emit d_ptr->updatedBars();
                     emit labelFontChanged();
                 }
             }
             /*!
                 Returns the pen for values that are drawn on top of this barset
             */
             QFont QBarSet::labelFont() const
             {
                 return d_ptr->m_labelFont;
             }
             /*!
                 Returns the color of the brush of barset.
             */
             QColor QBarSet::color()
             {
                 return brush().color();
             }
             /*!
                 Sets the \a color of brush for this barset
             */
             void QBarSet::setColor(QColor color)
             {
                 QBrush b = brush();
                 if ((b.color() != color) || (b.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
             */
             QColor QBarSet::borderColor()
             {
                 return pen().color();
             }
             /*!
                 Sets the color of pen for this barset
             */
             void QBarSet::setBorderColor(QColor color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             /*!
                 Returns the color of labels of this barset
             */
             QColor QBarSet::labelColor()
             {
                 return labelBrush().color();
             }
             /*!
                 Sets the color of labels for this barset
             */
             void QBarSet::setLabelColor(QColor color)
             {
                 QBrush b = labelBrush();
                 if (b == 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)
             {
             }
             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 +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 "qhbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHBarModelMapper
                 \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.
+                \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
                 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
                 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
                 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 +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 "qvbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QVBarModelMapper
                 \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.
+                \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
                 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
                 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
                 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/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
                 \mainclass
-                QLegend is a graphical object, whics displays legend of the chart. Legend state is updated by QChart, when
+                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/piechart/qhpiemodelmapper.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 "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.
+                \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
                 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
                 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
                 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
                 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
+                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.
             */
             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
+                \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 +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 "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.
+                \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
                 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
                 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
                 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 +2 -8

             /****************************************************************************
             **
             ** 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 ChartSeries object with \a parent.
+                \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("Still binded series detected !");
+                    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;
             }
-            /*!
-                Sets the visibility of series to \a visible
-            */
             void QAbstractSeries::setVisible(bool visible)
             {
                 if (visible != d_ptr->m_visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged();
                 }
             }
-            /*!
-                Returns the visibility of series
-            */
             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
                 \sa setVisible(), isVisible()
             */
             void QAbstractSeries::show()
             {
                 setVisible(true);
             }
             /*!
                 \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/qchart.cpp +72 -86

             /****************************************************************************
             **
             ** 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 "qchart.h"
             #include "qchart_p.h"
             #include "legendscroller_p.h"
             #include "qlegend_p.h"
             #include "chartbackground_p.h"
             #include "qabstractaxis.h"
             #include "abstractchartlayout_p.h"
             #include "charttheme_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              \enum QChart::ChartTheme
              This enum describes the theme used by the chart.
              \value ChartThemeLight The default theme
              \value ChartThemeBlueCerulean
              \value ChartThemeDark
              \value ChartThemeBrownSand
              \value ChartThemeBlueNcs
              \value ChartThemeHighContrast
              \value ChartThemeBlueIcy
              */
             /*!
              \enum QChart::AnimationOption
              For enabling/disabling animations. Defaults to NoAnimation.
              \value NoAnimation
              \value GridAxisAnimations
              \value SeriesAnimations
              \value AllAnimations
              */
             /*!
              \enum QChart::ChartType
              This enum describes the chart type.
              \value ChartTypeUndefined
              \value ChartTypeCartesian
              \value ChartTypePolar
              */
             /*!
              \class QChart
              \brief QtCommercial chart API.
              QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
-             representation of different types of series and other chart related objects like
+             representation of different types of series and other chart related objects like legend and
-             QAxis and QLegend. If you simply want to show a chart in a layout, you can use the
+             axes. If you simply want to show a chart in a layout, you can use the
              convenience class QChartView instead of QChart.
-             \sa QChartView
+             \sa QChartView, QPolarChart
              */
             /*!
              \property QChart::animationOptions
              The animation \a options for the chart. Animations are enabled/disabled based on this setting.
              */
             /*!
              \property QChart::backgroundVisible
-             Whether the chart background is visible or not.
+             Specifies whether the chart background is visible or not.
              \sa setBackgroundBrush(), setBackgroundPen()
              */
             /*!
              \property QChart::dropShadowEnabled
              If set to true, the background drop shadow effect is enabled. If set to false, it is disabled. Note that the drop
              shadow effect depends on theme, which means the setting may be changed if you switch to another theme.
              */
             /*!
              \property QChart::minimumMargins
              Minimum margins between the plot area (axes) and the edge of the chart widget.
+             This property is deprecated; use margins property instead.
+             \sa margins
              */
             /*!
              \property QChart::margins
-             Minimum between the plot area (axes) and the edge of the chart widget.
+             Margins between the plot area (axes) and the edge of the chart widget.
              */
             /*!
              \property QChart::theme
              Theme is a built-in collection of UI style related settings applied for all visual elements of a chart, like colors,
-             pens, brushes and fonts of series, axes, title and legend. \l {Chart themes demo} shows an example with a few
+             pens, brushes, and fonts of series, axes, title, and legend. \l {Chart themes demo} shows an example with a few
              different themes.
-             Note: changing the theme will overwrite all customizations previously applied to the series.
+             \note Changing the theme will overwrite all customizations previously applied to the series.
              */
             /*!
              \property QChart::title
              Title is the name (label) of a chart. It is shown as a headline on top of the chart.
              */
             /*!
              \property QChart::chartType
              Chart type indicates if the chart is a cartesian chart or a polar chart.
-             This property is set internally and is read only.
+             This property is set internally and it is read only.
              \sa QPolarChart
              */
             /*!
              \internal
              Constructs a chart object of \a type which is a child of a \a parent.
              Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              This constructor is called only by subclasses.
             */
             QChart::QChart(QChart::ChartType type, QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 : QGraphicsWidget(parent, wFlags),
                   d_ptr(new QChartPrivate(this, type))
             {
                 d_ptr->init();
             }
             /*!
              Constructs a chart object which is a child of a \a parent.
              Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 : QGraphicsWidget(parent, wFlags),
                   d_ptr(new QChartPrivate(this, ChartTypeCartesian))
             {
                 d_ptr->init();
             }
             /*!
-             Destroys the object and it's children, like series and axis objects added to it.
+             Destroys the chart object and its children, like series and axis objects added to it.
              */
             QChart::~QChart()
             {
                 //start by deleting dataset, it will remove all series and axes
                 delete d_ptr->m_dataset;
                 d_ptr->m_dataset = 0;
             }
             /*!
-             Adds the \a series onto the chart and takes the ownership of the object.
+             Adds the \a series onto the chart and takes the ownership of it.
-             If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
-             the y axis).
+             \note A newly added series is attached to no axes by default, including any axes that were created for the chart
+             using createDefaultAxes() before the series was added to the chart. If no axes are attached to
+             the newly added series before the chart is shown, the series will get drawn as if it had axes with ranges
+             that exactly fit the series to the plot area of the chart. This can be confusing if the same chart also displays other
+             series that have properly attached axes, so always make sure you either call createDefaultAxes() after
+             a series has been added or explicitly attach axes for the series.
-             \sa removeSeries(), removeAllSeries()
+             \sa removeSeries(), removeAllSeries(), createDefaultAxes(), QAbstractSeries::attachAxis()
              */
             void QChart::addSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->addSeries(series);
             }
             /*!
-             Removes the \a series specified in a perameter from the QChartView.
+             Removes the \a series from the chart.
-             It releses its ownership of the specified QChartSeries object.
+             The chart releases its ownership of the specified \a series object.
-             It does not delete the pointed QChartSeries data object
              \sa addSeries(), removeAllSeries()
              */
             void QChart::removeSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->removeSeries(series);
             }
             /*!
-             Removes all the QChartSeries that have been added to the QChartView
+             Removes and deletes all series objects that have been added to the chart.
-             It also deletes the pointed QChartSeries data objects
              \sa addSeries(), removeSeries()
              */
             void QChart::removeAllSeries()
             {
                 foreach (QAbstractSeries *s ,  d_ptr->m_dataset->series()){
                     removeSeries(s);
                     delete s;
                 }
             }
             /*!
              Sets the \a brush that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setBackgroundBrush(brush);
             }
             /*!
              Gets the brush that is used for painting the background of the chart area.
              */
             QBrush QChart::backgroundBrush() const
             {
                 return d_ptr->m_presenter->backgroundBrush();
             }
             /*!
              Sets the \a pen that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundPen(const QPen &pen)
             {
                 d_ptr->m_presenter->setBackgroundPen(pen);
             }
             /*!
              Gets the pen that is used for painting the background of the chart area.
              */
             QPen QChart::backgroundPen() const
             {
                 return d_ptr->m_presenter->backgroundPen();
             }
-            /*!
-             Sets the chart \a title. The description text that is drawn above the chart.
-             */
             void QChart::setTitle(const QString &title)
             {
                 d_ptr->m_presenter->setTitle(title);
             }
-            /*!
-             Returns the chart title. The description text that is drawn above the chart.
-             */
             QString QChart::title() const
             {
                 return d_ptr->m_presenter->title();
             }
             /*!
-             Sets the \a font that is used for drawing the chart description text that is rendered above the chart.
+             Sets the \a font that is used for drawing the chart title.
              */
             void QChart::setTitleFont(const QFont &font)
             {
                 d_ptr->m_presenter->setTitleFont(font);
             }
             /*!
-                Gets the font that is used for drawing the chart description text that is rendered above the chart.
+             Gets the font that is used for drawing the chart title.
              */
             QFont QChart::titleFont() const
             {
                 return d_ptr->m_presenter->titleFont();
             }
             /*!
-             Sets the \a brush used for rendering the title text.
+             Sets the \a brush used for drawing the title text.
              */
             void QChart::setTitleBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setTitleBrush(brush);
             }
             /*!
-             Returns the brush used for rendering the title text.
+             Returns the brush used for drawing the title text.
              */
             QBrush QChart::titleBrush() const
             {
                 return d_ptr->m_presenter->titleBrush();
             }
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 d_ptr->m_themeManager->setTheme(theme);
             }
             QChart::ChartTheme QChart::theme() const
             {
                 return d_ptr->m_themeManager->theme()->id();
             }
             /*!
-             Zooms in the view by a factor of 2
+             Zooms in the view by a factor of two.
              */
             void QChart::zoomIn()
             {
                 d_ptr->zoomIn(2.0);
             }
             /*!
              Zooms in the view to a maximum level at which \a rect is still fully visible.
              \note This is not supported for polar charts.
              */
             void QChart::zoomIn(const QRectF &rect)
             {
                 if (d_ptr->m_type == QChart::ChartTypePolar)
                     return;
                 d_ptr->zoomIn(rect);
             }
             /*!
-             Restores the view zoom level to the previous one.
+             Zooms out the view by a factor of two.
              */
             void QChart::zoomOut()
             {
                 d_ptr->zoomOut(2.0);
             }
             /*!
-             Zooms in the view by a \a factor.
+             Zooms in the view by a custom \a factor.
              A factor over 1.0 zooms the view in and factor between 0.0 and 1.0 zooms out.
              */
             void QChart::zoom(qreal factor)
             {
                 if (qFuzzyCompare(factor, 0))
                     return;
                 if (qFuzzyCompare(factor, (qreal)1.0))
                     return;
                 if (factor < 0)
                     return;
                 if (factor > 1.0)
                     d_ptr->zoomIn(factor);
                 else
                     d_ptr->zoomOut(1.0 / factor);
             }
             /*!
-             Returns the pointer to the x axis object of the chart associated with the specified \a series.
+             Returns a pointer to the horizontal axis attached to the specified \a series.
-             If no series is provided then pointer to currently visible axis is provided.
+             If no \a series is specified, the first horizontal axis added to the chart is returned.
+             \sa addAxis(), QAbstractSeries::attachAxis()
              */
             QAbstractAxis *QChart::axisX(QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> axisList = axes(Qt::Horizontal, series);
                 if (axisList.count())
                     return axisList[0];
                 return 0;
             }
             /*!
-             Returns the pointer to the y axis object of the chart associated with the specified \a series.
+             Returns a pointer to the vertical axis attached to the specified \a series.
-             If no series is provided then pointer to currently visible axis is provided.
+             If no \a series is specified, the first vertical axis added to the chart is returned.
+             \sa addAxis(), QAbstractSeries::attachAxis()
              */
             QAbstractAxis *QChart::axisY(QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> axisList = axes(Qt::Vertical, series);
                 if (axisList.count())
                     return axisList[0];
                 return 0;
             }
             /*!
-             Returns the axes added for the \a series with \a orientation. If no series is provided, then all axes with the
+             Returns the axes attached to the \a series with \a orientation. If no \a series is provided,
-             specified orientation are returned.
+             then all axes added to the chart with the specified orientation are returned.
              \sa addAxis(), createDefaultAxes()
              */
             QList<QAbstractAxis *> QChart::axes(Qt::Orientations orientation, QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> result ;
                 if (series) {
                     foreach (QAbstractAxis *axis, series->attachedAxes()){
                         if (orientation.testFlag(axis->orientation()))
                             result << axis;
                     }
                 } else {
                     foreach (QAbstractAxis *axis, d_ptr->m_dataset->axes()){
                         if (orientation.testFlag(axis->orientation()) && !result.contains(axis))
                             result << axis;
                     }
                 }
                 return result;
             }
             /*!
-             NOTICE: This function has to be called after series has been added to the chart if no customized axes are set to the chart. Otherwise axisX(), axisY() calls return NULL.
+             Creates axes for the chart based on the series that have already been added to the chart. Any axes previously added to
+             the chart will be deleted.
-             Creates the axes for the chart based on the series that has already been added to the chart.
+             \note This function has to be called after all series have been added to the chart. The axes created by this function
+             will NOT get automatically attached to any series added to the chart after this function has been called.
+             A series with no axes attached will by default scale to utilize the entire plot area of the chart, which can be confusing
+             if there are other series with properly attached axes also present.
              \table
                  \header
                      \o Series type
                      \o X-axis
                      \o Y-axis
                  \row
                      \o QXYSeries
                      \o QValueAxis
                      \o QValueAxis
                  \row
                      \o QBarSeries
                      \o QBarCategoryAxis
                      \o QValueAxis
                  \row
                      \o QPieSeries
                      \o None
                      \o None
              \endtable
-             If there are several QXYSeries derived series added to the chart and no other series type has been added then only one pair of axes is created.
+             If there are several QXYSeries derived series added to the chart and no series of other types have been added, then only one pair of axes is created.
-             If there are sevaral series added of different types then each series gets its own axes pair.
+             If there are several series of different types added to the chart, then each series gets its own axes pair.
-             NOTICE: if there is more than one x and y axes created then no axis is drawn by default and one needs to choose explicitly which axis should be shown.
+             The axes specific to the series can be later obtained from the chart by providing the series as the parameter for axes() function call.
-             Axis specifix to the series can be later obtained from the chart by providing the series as the parameter of axisX(), axisY() function calls.
              QPieSeries does not create any axes.
-             \sa axisX(), axisY(), setAxisX(), setAxisY()
+             \sa axisX(), axisY(), axes(), setAxisX(), setAxisY(), QAbstractSeries::attachAxis()
              */
             void QChart::createDefaultAxes()
             {
                 d_ptr->m_dataset->createDefaultAxes();
             }
             /*!
-             Returns the legend object of the chart. Ownership stays in chart.
+             Returns the legend object of the chart. Ownership stays with the chart.
              */
             QLegend *QChart::legend() const
             {
                 return d_ptr->m_legend;
             }
-            /*!
-              Sets the minimum \a margins between the plot area (axes) and the edge of the chart widget.
-              Deprecated. Use setMargins().
-            */
             void QChart::setMinimumMargins(const QMargins &margins)
             {
                 qWarning() << "QChart::setMinimumMargins is deprecated. Use QChart::setMargins instead.";
                 d_ptr->m_presenter->layout()->setMargins(margins);
             }
-            /*!
-                Returns the rect that contains information about margins (distance between chart widget edge and axes).
-                Individual margins can be obtained by calling left, top, right, bottom on the returned rect.
-                Deprecated. Use margins().
-             */
             QMargins QChart::minimumMargins() const
             {
                 qWarning() << "QChart::minimumMargins is deprecated. Use QChart::margins instead.";
                 return d_ptr->m_presenter->layout()->margins();
             }
-            /*!
-              Sets the minimum \a margins between the plot area (axes) and the edge of the chart widget.
-            */
             void QChart::setMargins(const QMargins &margins)
             {
                 d_ptr->m_presenter->layout()->setMargins(margins);
             }
-            /*!
-                Returns the rect that contains information about margins (distance between chart widget edge and axes).
-                Individual margins can be obtained by calling left, top, right, bottom on the returned rect.
-             */
             QMargins QChart::margins() const
             {
                 return d_ptr->m_presenter->layout()->margins();
             }
             QChart::ChartType QChart::chartType() const
             {
                 return d_ptr->m_type;
             }
             /*!
-                Returns the the rect within which the drawing of the chart is done.
+                Returns the the rectangle within which the drawing of the chart is done.
-                It does not include the area defines by margins.
+                It does not include the area defined by margins.
              */
             QRectF QChart::plotArea() const
             {
                 return d_ptr->m_presenter->geometry();
             }
-            ///*!
-            //    TODO: Dummy.
-            //    Adjust the ranges of the axes so that all the data of the specified \a series is visible
-            // */
-            //void QChart::adjustViewToSeries(QAbstractSeries* series)
-            //{
-            //    //
-            //}
-            /*!
-             Sets animation \a options for the chart
-             */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 d_ptr->m_presenter->setAnimationOptions(options);
             }
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return d_ptr->m_presenter->animationOptions();
             }
             /*!
                 Scrolls the visible area of the chart by the distance defined in the \a dx and \a dy.
                 For polar charts, \a dx indicates the angle along angular axis instead of distance.
              */
             void QChart::scroll(qreal dx, qreal dy)
             {
                 d_ptr->scroll(dx,dy);
             }
             void QChart::setBackgroundVisible(bool visible)
             {
                 d_ptr->m_presenter->setBackgroundVisible(visible);
             }
             bool QChart::isBackgroundVisible() const
             {
                 return d_ptr->m_presenter->isBackgroundVisible();
             }
             void QChart::setDropShadowEnabled(bool enabled)
             {
                 d_ptr->m_presenter->setBackgroundDropShadowEnabled(enabled);
             }
             bool QChart::isDropShadowEnabled() const
             {
                 return d_ptr->m_presenter->isBackgroundDropShadowEnabled();
             }
             /*!
-              Returns all the series that are added to the chart.
+              Returns all series that are added to the chart.
               \sa addSeries(), removeSeries(), removeAllSeries()
             */
             QList<QAbstractSeries *> QChart::series() const
             {
                 return d_ptr->m_dataset->series();
             }
             /*!
-              Sets \a axis to the chart, which will control the presentation of the \a series
+              Adds the \a axis to the chart and attaches it to the \a series as a bottom-aligned horizontal axis.
+              The chart takes ownership of both the \a axis and the \a series.
+              Any horizontal axes previously attached to the \a series are deleted.
-               \sa axisX(), axisY(), setAxisY(), createDefaultAxes()
+              \sa axisX(), axisY(), setAxisY(), createDefaultAxes(), QAbstractSeries::attachAxis()
             */
             void QChart::setAxisX(QAbstractAxis *axis ,QAbstractSeries *series)
             {
                 QList<QAbstractAxis*> list = axes(Qt::Horizontal, series);
                 foreach (QAbstractAxis* a, list) {
                     d_ptr->m_dataset->removeAxis(a);
                     delete a;
                 }
                 if (!d_ptr->m_dataset->axes().contains(axis))
                     d_ptr->m_dataset->addAxis(axis, Qt::AlignBottom);
                 d_ptr->m_dataset->attachAxis(series, axis);
             }
             /*!
-              Sets \a axis to the chart, which will control the presentation of the \a series
+              Adds the \a axis to the chart and attaches it to the \a series as a left-aligned vertical axis.
+              The chart takes ownership of both the \a axis and the \a series.
+              Any vertical axes previously attached to the \a series are deleted.
-               \sa axisX(), axisY(), setAxisX(), createDefaultAxes()
+              \sa axisX(), axisY(), setAxisX(), createDefaultAxes(), QAbstractSeries::attachAxis()
             */
             void QChart::setAxisY(QAbstractAxis *axis ,QAbstractSeries *series)
             {
                 QList<QAbstractAxis*> list = axes(Qt::Vertical, series);
                 foreach (QAbstractAxis* a, list) {
                     d_ptr->m_dataset->removeAxis(a);
                     delete a;
                 }
                 if (!d_ptr->m_dataset->axes().contains(axis))
                     d_ptr->m_dataset->addAxis(axis, Qt::AlignLeft);
                 d_ptr->m_dataset->attachAxis(series, axis);
             }
             /*!
-              Adds \a axis to the chart with \a alignment. The chart takes the ownership of the axis.
+              Adds the \a axis to the chart with \a alignment. The chart takes the ownership of the axis.
               \sa removeAxis(), createDefaultAxes(), QAbstractSeries::attachAxis()
             */
             void QChart::addAxis(QAbstractAxis *axis, Qt::Alignment alignment)
             {
                 d_ptr->m_dataset->addAxis(axis, alignment);
             }
             /*!
-              Removes \a axis from the chart. The ownership is returned to the caller.
+              Removes the \a axis from the chart.
+              The chart releases its ownership of the specified \a axis object.
               \sa addAxis(), createDefaultAxes(), QAbstractSeries::detachAxis()
             */
             void QChart::removeAxis(QAbstractAxis *axis)
             {
                 d_ptr->m_dataset->removeAxis(axis);
             }
             /*!
-              Returns the value in the \a series domain that corresponds to the charts widget point defines by \a position.
+              Returns the value in the \a series domain that corresponds to the \a position relative to chart widget.
             */
             QPointF QChart::mapToValue(const QPointF &position, QAbstractSeries *series)
             {
                 return d_ptr->m_dataset->mapToValue(position, series);
             }
             /*!
-              Returns the position on the charts widget that corresponds to the \a value in the \a series domain.
+              Returns the position on the chart widget that corresponds to the \a value in the \a series domain.
             */
             QPointF QChart::mapToPosition(const QPointF &value, QAbstractSeries *series)
             {
                 return d_ptr->m_dataset->mapToPosition(value, series);
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartPrivate::QChartPrivate(QChart *q, QChart::ChartType type):
                 q_ptr(q),
                 m_type(type),
                 m_legend(0),
                 m_dataset(new ChartDataSet(q)),
                 m_presenter(new ChartPresenter(q, type)),
                 m_themeManager(new ChartThemeManager(q))
             {
                 QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), m_presenter, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), m_presenter, SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)), m_presenter, SLOT(handleAxisAdded(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)), m_presenter, SLOT(handleAxisRemoved(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), m_themeManager, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), m_themeManager, SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)), m_themeManager, SLOT(handleAxisAdded(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)), m_themeManager, SLOT(handleAxisRemoved(QAbstractAxis*)));
             }
             QChartPrivate::~QChartPrivate()
             {
             }
             void QChartPrivate::init()
             {
                 m_legend = new LegendScroller(q_ptr);
                 q_ptr->setTheme(QChart::ChartThemeLight);
                 q_ptr->setLayout(m_presenter->layout());
             }
             void QChartPrivate::zoomIn(qreal factor)
             {
                 QRectF rect = m_presenter->geometry();
                 rect.setWidth(rect.width() / factor);
                 rect.setHeight(rect.height() / factor);
                 rect.moveCenter(m_presenter->geometry().center());
                 zoomIn(rect);
             }
             void QChartPrivate::zoomIn(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
                 QRectF r = rect.normalized();
                 const QRectF geometry = m_presenter->geometry();
                 r.translate(-geometry.topLeft());
                 if (!r.isValid())
                     return;
                 QPointF zoomPoint(r.center().x() / geometry.width(), r.center().y() / geometry.height());
                 m_presenter->setState(ChartPresenter::ZoomInState,zoomPoint);
                 m_dataset->zoomInDomain(r);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             void QChartPrivate::zoomOut(qreal factor)
             {
                 const QRectF geometry = m_presenter->geometry();
                 QRectF r;
                 r.setSize(geometry.size() / factor);
                 r.moveCenter(QPointF(geometry.size().width()/2 ,geometry.size().height()/2));
                 if (!r.isValid())
                     return;
                 QPointF zoomPoint(r.center().x() / geometry.width(), r.center().y() / geometry.height());
                 m_presenter->setState(ChartPresenter::ZoomOutState,zoomPoint);
                 m_dataset->zoomOutDomain(r);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             void QChartPrivate::scroll(qreal dx, qreal dy)
             {
                 if (dx < 0) m_presenter->setState(ChartPresenter::ScrollLeftState,QPointF());
                 if (dx > 0) m_presenter->setState(ChartPresenter::ScrollRightState,QPointF());
                 if (dy < 0) m_presenter->setState(ChartPresenter::ScrollUpState,QPointF());
                 if (dy > 0) m_presenter->setState(ChartPresenter::ScrollDownState,QPointF());
                 m_dataset->scrollDomain(dx, dy);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartview.cpp +20 -17

             /****************************************************************************
             **
             ** 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 "qchartview.h"
             #include "qchartview_p.h"
             #include "qchart_p.h"
             #include <QGraphicsScene>
             #include <QRubberBand>
             /*!
                 \enum QChartView::RubberBand
                 This enum describes the different types of rubber bands that can be used for zoom rect selection
                 \value NoRubberBand
                 \value VerticalRubberBand
                 \value HorizonalRubberBand
                 \value RectangleRubberBand
             */
             /*!
                 \class QChartView
                 \brief Standalone charting widget.
                 QChartView is a standalone widget that can display charts. It does not require separate
-                QGraphicsScene to work. It manages the graphical representation of different types of
+                QGraphicsScene to work. If you want to display a chart in your existing QGraphicsScene,
-                series and other chart related objects like QAxis and QLegend. If you want to
+                you need to use the QChart (or QPolarChart) class instead.
-                display a chart in your existing QGraphicsScene, you can use the QChart class instead.
-                \sa QChart
+                \sa QChart, QPolarChart
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs a chartView object with parent \a parent.
             */
             QChartView::QChartView(QWidget *parent)
                 : QGraphicsView(parent),
                   d_ptr(new QChartViewPrivate(this))
             {
             }
             /*!
-                Constructs a chartView object with parent \a parent to display a \a chart.
+                Constructs a chartview object with parent \a parent to display a \a chart.
+                Ownership of the \a chart is passed to chartview.
             */
             QChartView::QChartView(QChart *chart, QWidget *parent)
                 : QGraphicsView(parent),
                   d_ptr(new QChartViewPrivate(this, chart))
             {
             }
             /*!
-                Destroys the object and it's children, like series and axis objects added to it.
+                Destroys the chartview object and the associated chart.
             */
             QChartView::~QChartView()
             {
             }
             /*!
-                Returns the pointer to the associated chart
+                Returns the pointer to the associated chart.
             */
             QChart *QChartView::chart() const
             {
                 return d_ptr->m_chart;
             }
             /*!
                 Sets the current chart to \a chart. Ownership of the new chart is passed to chartview
                 and ownership of the previous chart is released.
-                To avoid memory leaks users needs to make sure the previous chart is deleted.
+                To avoid memory leaks users need to make sure the previous chart is deleted.
             */
             void QChartView::setChart(QChart *chart)
             {
                 d_ptr->setChart(chart);
             }
             /*!
-                Sets the RubberBandPlicy to \a rubberBand. Selected policy determines the way zooming is performed.
+                Sets the rubber band flags to \a rubberBand.
+                Selected flags determine the way zooming is performed.
+                \note Rubber band zooming is not supported for polar charts.
             */
             void QChartView::setRubberBand(const RubberBands &rubberBand)
             {
                 d_ptr->m_rubberBandFlags = rubberBand;
                 if (!d_ptr->m_rubberBandFlags) {
                     delete d_ptr->m_rubberBand;
                     d_ptr->m_rubberBand = 0;
                     return;
                 }
                 if (!d_ptr->m_rubberBand) {
                     d_ptr->m_rubberBand = new QRubberBand(QRubberBand::Rectangle, this);
                     d_ptr->m_rubberBand->setEnabled(true);
                 }
             }
             /*!
-                Returns the RubberBandPolicy that is currently being used by the widget.
+                Returns the rubber band flags that are currently being used by the widget.
             */
             QChartView::RubberBands QChartView::rubberBand() const
             {
                 return d_ptr->m_rubberBandFlags;
             }
             /*!
-                If Left mouse button is pressed and the RubberBandPolicy is enabled the \a event is accepted and the rubber band is displayed on the screen allowing the user to select the zoom area.
+                If Left mouse button is pressed and the rubber band is enabled the \a event is accepted and the rubber band is displayed on the screen allowing the user to select the zoom area.
-                If different mouse button is pressed and/or the RubberBandPolicy is disabled then the \a event is passed to QGraphicsView::mousePressEvent() implementation.
+                If different mouse button is pressed and/or the rubber band is disabled then the \a event is passed to QGraphicsView::mousePressEvent() implementation.
             */
             void QChartView::mousePressEvent(QMouseEvent *event)
             {
                 if (d_ptr->m_rubberBand && d_ptr->m_rubberBand->isEnabled() && event->button() == Qt::LeftButton) {
                     QRectF plotArea = d_ptr->m_chart->plotArea();
                     if (plotArea.contains(event->pos())) {
                         d_ptr->m_rubberBandOrigin = event->pos();
                         d_ptr->m_rubberBand->setGeometry(QRect(d_ptr->m_rubberBandOrigin, QSize()));
                         d_ptr->m_rubberBand->show();
                         event->accept();
                     }
                 } else {
                     QGraphicsView::mousePressEvent(event);
                 }
             }
             /*!
-                If RubberBand rectange specification has been initiated in pressEvent then \a event data is used to update RubberBand geometry.
+                If the rubber band rectange has been displayed in pressEvent then \a event data is used to update the rubber band geometry.
-                In other case the defualt QGraphicsView::mouseMoveEvent implementation is called.
+                Otherwise the default QGraphicsView::mouseMoveEvent implementation is called.
             */
             void QChartView::mouseMoveEvent(QMouseEvent *event)
             {
                 if (d_ptr->m_rubberBand && d_ptr->m_rubberBand->isVisible()) {
                     QRect rect = d_ptr->m_chart->plotArea().toRect();
                     int width = event->pos().x() - d_ptr->m_rubberBandOrigin.x();
                     int height = event->pos().y() - d_ptr->m_rubberBandOrigin.y();
                     if (!d_ptr->m_rubberBandFlags.testFlag(VerticalRubberBand)) {
                         d_ptr->m_rubberBandOrigin.setY(rect.top());
                         height = rect.height();
                     }
                     if (!d_ptr->m_rubberBandFlags.testFlag(HorizonalRubberBand)) {
                         d_ptr->m_rubberBandOrigin.setX(rect.left());
                         width = rect.width();
                     }
                     d_ptr->m_rubberBand->setGeometry(QRect(d_ptr->m_rubberBandOrigin.x(), d_ptr->m_rubberBandOrigin.y(), width, height).normalized());
                 } else {
                     QGraphicsView::mouseMoveEvent(event);
                 }
             }
             /*!
-                If left mouse button is release and RubberBand is enabled then \a event is accepted and the view is zoomed in to rect specified by RubberBand
+                If left mouse button is released and the rubber band is enabled then \a event is accepted and
-                If it is the right mouse button \a event then RubberBand is dissmissed and zoom is canceled.
+                the view is zoomed into the rect specified by the rubber band.
+                If it is a right mouse button \a event then the rubber band is dismissed and the zoom is canceled.
             */
             void QChartView::mouseReleaseEvent(QMouseEvent *event)
             {
                 if (d_ptr->m_rubberBand) {
                     if (event->button() == Qt::LeftButton && d_ptr->m_rubberBand->isVisible()) {
                         d_ptr->m_rubberBand->hide();
                         QRectF rect = d_ptr->m_rubberBand->geometry();
                         // Since plotArea uses QRectF and rubberband uses QRect, we can't just blindly use
                         // rubberband's dimensions for vertical and horizontal rubberbands, where one
                         // dimension must match the corresponding plotArea dimension exactly.
                         if (d_ptr->m_rubberBandFlags == VerticalRubberBand) {
                             rect.setX(d_ptr->m_chart->plotArea().x());
                             rect.setWidth(d_ptr->m_chart->plotArea().width());
                         } else if (d_ptr->m_rubberBandFlags == HorizonalRubberBand) {
                             rect.setY(d_ptr->m_chart->plotArea().y());
                             rect.setHeight(d_ptr->m_chart->plotArea().height());
                         }
                         d_ptr->m_chart->zoomIn(rect);
                         event->accept();
                     }
                     if (event->button() == Qt::RightButton) {
                         d_ptr->m_chart->zoomOut();
                         event->accept();
                     }
                 } else {
                     QGraphicsView::mouseReleaseEvent(event);
                 }
             }
             /*!
                 Resizes and updates the chart area using the \a event data
             */
             void QChartView::resizeEvent(QResizeEvent *event)
             {
                 QGraphicsView::resizeEvent(event);
                 d_ptr->resize();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartViewPrivate::QChartViewPrivate(QChartView *q, QChart *chart)
                 : q_ptr(q),
                   m_scene(new QGraphicsScene(q)),
                   m_chart(chart),
                   m_rubberBand(0),
                   m_rubberBandFlags(QChartView::NoRubberBand)
             {
                 q_ptr->setFrameShape(QFrame::NoFrame);
                 q_ptr->setBackgroundRole(QPalette::Window);
                 q_ptr->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 q_ptr->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 q_ptr->setScene(m_scene);
                 q_ptr->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 if (!m_chart)
                     m_chart = new QChart();
                 m_scene->addItem(m_chart);
             }
             QChartViewPrivate::~QChartViewPrivate()
             {
             }
             void QChartViewPrivate::setChart(QChart *chart)
             {
                 Q_ASSERT(chart);
                 if (m_chart == chart)
                     return;
                 if (m_chart)
                     m_scene->removeItem(m_chart);
                 m_chart = chart;
                 m_scene->addItem(m_chart);
                 resize();
             }
             void QChartViewPrivate::resize()
             {
                 m_chart->resize(q_ptr->size());
                 q_ptr->setMinimumSize(m_chart->minimumSize().toSize());
                 q_ptr->setSceneRect(m_chart->geometry());
             }
             #include "moc_qchartview.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qpolarchart.cpp +7 -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 "qpolarchart.h"
             #include "qabstractaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \enum QPolarChart::PolarOrientation
-               This type is used to signify the polar orientation of an axis.
+               This type is used to specify the polar orientation of an axis.
                 \value PolarOrientationRadial
                 \value PolarOrientationAngular
             */
             /*!
              \class QPolarChart
              \brief QtCommercial chart API.
              QPolarChart is a specialization of QChart to show a polar chart.
              Polar charts support line, spline, area, and scatter series, and all axis types
              supported by those series.
              \note When setting ticks to an angular QValueAxis, keep in mind that the first and last tick
              are co-located at 0/360 degree angle.
              \note If the angular distance between two consecutive points in a series is more than 180 degrees,
              any line connecting the two points becomes meaningless, so choose the axis ranges accordingly
-             when displaying line, spline, or area series.
+             when displaying line, spline, or area series. In such case series don't draw a direct line between
+             the two points, but instead draw a line to and from the center of the chart.
              \note Polar charts do not support multiple axes of same orientation.
              \sa QChart
              */
             /*!
-             Constructs a polar chart as a child of a \a parent.
+             Constructs a polar chart as a child of the \a parent.
              Parameter \a wFlags is passed to the QChart constructor.
              */
             QPolarChart::QPolarChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 : QChart(QChart::ChartTypePolar, parent, wFlags)
             {
             }
             /*!
-             Destroys the object and it's children, like series and axis objects added to it.
+             Destroys the polar chart object and its children, like series and axis objects added to it.
              */
             QPolarChart::~QPolarChart()
             {
             }
             /*!
              Returns the axes added for the \a series with \a polarOrientation. If no series is provided, then any axis with the
              specified polar orientation is returned.
              \sa addAxis()
              */
             QList<QAbstractAxis *> QPolarChart::axes(PolarOrientations polarOrientation, QAbstractSeries *series) const
             {
                 Qt::Orientations orientation(0);
                 if (polarOrientation.testFlag(PolarOrientationAngular))
                     orientation |= Qt::Horizontal;
                 if (polarOrientation.testFlag(PolarOrientationRadial))
                     orientation |= Qt::Vertical;
                 return QChart::axes(orientation, series);
             }
             /*!
               This convenience method adds \a axis to the polar chart with \a polarOrientation.
               The chart takes the ownership of the axis.
               \note Axes can be added to a polar chart also with QChart::addAxis() instead of this method.
               The specified alignment determines the polar orientation: horizontal alignments indicate angular
               axis and vertical alignments indicate radial axis.
               \sa QChart::removeAxis(), QChart::createDefaultAxes(), QAbstractSeries::attachAxis(), QChart::addAxis()
             */
             void QPolarChart::addAxis(QAbstractAxis *axis, PolarOrientation polarOrientation)
             {
                 if (!axis || axis->type() == QAbstractAxis::AxisTypeBarCategory) {
                     qWarning("QAbstractAxis::AxisTypeBarCategory is not a supported axis type for polar charts.");
                 } else {
                     Qt::Alignment alignment = Qt::AlignLeft;
                     if (polarOrientation == PolarOrientationAngular)
                         alignment = Qt::AlignBottom;
                     QChart::addAxis(axis, alignment);
                 }
             }
             /*!
               Angular axes of a polar chart report horizontal orientation and radial axes report
               vertical orientation.
               This function is a convenience function for converting the orientation of an \a axis to
               corresponding polar orientation. If the \a axis is NULL or not added to a polar chart,
               the return value is meaningless.
             */
             QPolarChart::PolarOrientation QPolarChart::axisPolarOrientation(QAbstractAxis *axis)
             {
                 if (axis && axis->orientation() == Qt::Horizontal)
                     return PolarOrientationAngular;
                 else
                     return PolarOrientationRadial;
             }
             #include "moc_qpolarchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.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 "qsplineseries.h"
             #include "qsplineseries_p.h"
             #include "splinechartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "splineanimation_p.h"
             /*!
                 \class QSplineSeries
                 \brief Series type used to store data needed to draw a spline.
                 QSplineSeries stores the data points along with the segment control points needed by QPainterPath to draw spline
                 Control points are automatically calculated when data changes. The algorithm computes the points so that the normal spline can be drawn.
                 \image examples_splinechart.png
                 Creating basic spline chart is simple:
                 \code
                 QSplineSeries* series = new QSplineSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chart->addSeries(series);
                 \endcode
             */
             /*!
                 \qmlclass SplineSeries QSplineSeries
                 \inherits XYSeries
                 The following QML shows how to create a simple spline chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View3.qml 1
                 \beginfloatleft
                 \image demos_qmlchart3.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \fn QSeriesType QSplineSeries::type() const
                 Returns the type of the series
             */
             /*!
                 \qmlproperty real SplineSeries::width
                 The width of the line. By default the width is 2.0.
             */
             /*!
                 \qmlproperty Qt::PenStyle SplineSeries::style
                 Controls the style of the line. Set to one of Qt.NoPen, Qt.SolidLine, Qt.DashLine, Qt.DotLine,
                 Qt.DashDotLine or Qt.DashDotDotLine. Using Qt.CustomDashLine is not supported in the QML API.
                 By default the style is Qt.SolidLine.
             */
             /*!
                 \qmlproperty Qt::PenCapStyle SplineSeries::capStyle
                 Controls the cap style of the line. Set to one of Qt.FlatCap, Qt.SquareCap or Qt.RoundCap. By
                 default the cap style is Qt.SquareCap.
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs empty series object which is a child of \a parent.
-                When series object is added to QChartView or QChart instance then the ownerships is transferred.
+                When series object is added to a QChart instance then the ownerships is transferred.
               */
             QSplineSeries::QSplineSeries(QObject *parent)
                 : QLineSeries(*new QSplineSeriesPrivate(this), parent)
             {
             }
             /*!
               Destroys the object.
             */
             QSplineSeries::~QSplineSeries()
             {
                 Q_D(QSplineSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             QAbstractSeries::SeriesType QSplineSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeSpline;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QSplineSeriesPrivate::QSplineSeriesPrivate(QSplineSeries *q)
                 : QLineSeriesPrivate(q)
             {
             }
             void QSplineSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QSplineSeries);
                 SplineChartItem *spline = new SplineChartItem(q,parent);
                 m_item.reset(spline);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             void QSplineSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 Q_Q(QSplineSeries);
                 const QList<QColor> colors = theme->seriesColors();
                 QPen pen;
                 if (forced || pen == m_pen) {
                     pen.setColor(colors.at(index % colors.size()));
                     pen.setWidthF(2);
                     q->setPen(pen);
                 }
             }
             void QSplineSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
             {
                 SplineChartItem *item = static_cast<SplineChartItem *>(m_item.data());
                 Q_ASSERT(item);
                 if (options.testFlag(QChart::SeriesAnimations)) {
                     item->setAnimation(new SplineAnimation(item));
                 }else{
                     item->setAnimation(0);
                 }
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qsplineseries.cpp"
             #include "moc_qsplineseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.cpp +12 -13

             /****************************************************************************
             **
             ** 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 "qxyseries.h"
             #include "qxyseries_p.h"
             #include "abstractdomain_p.h"
             #include "qvalueaxis.h"
             #include "xychart_p.h"
             #include "qxylegendmarker.h"
             #include "charthelpers_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                 \qmlclass XYSeries
                 \inherits AbstractSeries
                 The XYSeries class is a base class for line, spline and scatter series.
                 The class cannot be instantiated directly.
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisX
                 The x axis used for the series. If you leave both axisX and axisXTop undefined, a ValueAxis is created for
                 the series.
                 \sa axisXTop
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::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 XYSeries::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 XYSeries::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
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisAngular
                 The angular axis used for the series, drawn around the polar chart view.
                 \sa axisX
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisRadial
                 The radial axis used for the series, drawn inside the polar chart view.
                 \sa axisY
             */
             /*!
                 \property QXYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                 \qmlproperty bool XYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \property QXYSeries::color
                 The color of the series. This is line (pen) color in case of QLineSeries or QSplineSeries and
                 fill (brush) color in case of QScatterSeries or QAreaSeries.
                 \sa QXYSeries::pen(), QXYSeries::brush()
             */
             /*!
                 \qmlproperty color XYSeries::color
                 The color of the series. This is line (pen) color in case of LineSeries or SplineSeries and
                 fill (brush) color in case of ScatterSeries or AreaSeries.
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart.
             */
             /*!
                 \qmlsignal XYSeries::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on chart. For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onClicked: console.log("onClicked: " + point.x + ", " + point.y);
                 }
                 \endcode
             */
             /*!
                 \fn void QXYSeries::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 XYSeries::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 QXYSeries::pointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
             */
             /*!
                 \fn void QXYSeries::pointsReplaced()
-                Signal is emitted when all points have been replaced with another points.
+                Signal is emitted when all points have been replaced with other points.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointsReplaced()
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal XYSeries::onPointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
                 \sa remove()
             */
             /*!
                 \qmlsignal XYSeries::onPointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
             */
             /*!
                 \fn void QXYSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \qmlsignal XYSeries::onColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \qmlmethod XYSeries::append(real x, real y)
                 Append point (\a x, \a y) to the series
             */
             /*!
                 \qmlmethod XYSeries::replace(real oldX, real oldY, real newX, real newY)
                 Replaces point (\a oldX, \a oldY) with point (\a newX, \a newY). Does nothing, if point (oldX, oldY) does not
                 exist.
             */
             /*!
                 \qmlmethod XYSeries::remove(real x, real y)
                 Removes point (\a x, \a y) from the series. Does nothing, if point (x, y) does not exist.
             */
             /*!
                 \qmlmethod XYSeries::insert(int index, real x, real y)
                 Inserts point (\a x, \a y) to the \a index. If index is 0 or smaller than 0 the point is prepended to the list of
                 points. If index is the same as or bigger than count, the point is appended to the list of points.
             */
             /*!
                 \qmlmethod QPointF XYSeries::at(int index)
                 Returns point at \a index. Returns (0, 0) if the index is not valid.
             */
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
-                When series object is added to QChartView or QChart instance ownerships is transferred.
+                When series object is added to QChart instance ownerships is transferred.
             */
             QXYSeries::QXYSeries(QXYSeriesPrivate &d, QObject *parent)
                 : QAbstractSeries(d, parent)
             {
             }
             /*!
-                Destroys the object. Series added to QChartView or QChart instances are owned by those,
+                Destroys the object. Series added to QChart instances are owned by those,
-                and are deleted when mentioned object are destroyed.
+                and are destroyed when QChart instances are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
-                Adds data point \a x \a y to the series. Points are connected with lines on the chart.
+                Adds data point (\a x, \a y) to the series.
              */
             void QXYSeries::append(qreal x, qreal y)
             {
                 append(QPointF(x, y));
             }
             /*!
                This is an overloaded function.
-               Adds data \a point to the series. Points are connected with lines on the chart.
+               Adds data \a point to the series.
              */
             void QXYSeries::append(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(point)) {
                     d->m_points << point;
                     emit pointAdded(d->m_points.count() - 1);
                 }
             }
             /*!
                This is an overloaded function.
-               Adds list of data \a points to the series. Points are connected with lines on the chart.
+               Adds list of data \a points to the series.
              */
             void QXYSeries::append(const QList<QPointF> &points)
             {
                 foreach (const QPointF &point , points)
                     append(point);
             }
             /*!
-              Replaces data point \a oldX \a oldY with data point \a newX \a newY.
+              Replaces data point (\a oldX, \a oldY) with data point (\a newX, \a newY).
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(qreal oldX, qreal oldY, qreal newX, qreal newY)
             {
                 replace(QPointF(oldX, oldY), QPointF(newX, newY));
             }
             /*!
               Replaces \a oldPoint with \a newPoint.
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(const QPointF &oldPoint, const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(oldPoint);
                 if (index == -1)
                     return;
                 if (isValidValue(newPoint)) {
                     d->m_points[index] = newPoint;
                     emit pointReplaced(index);
                 }
             }
             /*!
-              Replaces the current points with \a points. This is faster than replacing data points one by one,
+              Replaces the current points with \a points.
+              \note This is much faster than replacing data points one by one,
               or first clearing all data, and then appending the new data. Emits QXYSeries::pointsReplaced()
               when the points have been replaced.
               \sa QXYSeries::pointsReplaced()
             */
             void QXYSeries::replace(QList<QPointF> points)
             {
                 Q_D(QXYSeries);
                 d->m_points = points.toVector();
                 emit pointsReplaced();
             }
             /*!
-              Removes current \a x and \a y value.
+              Removes the point (\a x, \a y) from the series.
             */
             void QXYSeries::remove(qreal x, qreal y)
             {
                 remove(QPointF(x, y));
             }
             /*!
-              Removes current \a point x value.
+              Removes the \a point from the series.
-              Note: point y value is ignored.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if (index == -1)
                     return;
                 d->m_points.remove(index);
                 emit pointRemoved(index);
             }
             /*!
                Inserts a \a point in the series at \a index position.
             */
             void QXYSeries::insert(int index, const QPointF &point)
             {
                 Q_D(QXYSeries);
                 if (isValidValue(point)) {
                     d->m_points.insert(index, point);
                     emit pointAdded(index);
                 }
             }
             /*!
                 Removes all points from the series.
             */
             void QXYSeries::clear()
             {
                 Q_D(QXYSeries);
                 for (int i = d->m_points.size() - 1; i >= 0; i--)
                     remove(d->m_points.at(i));
             }
             /*!
                 Returns list of points in the series.
             */
             QList<QPointF> QXYSeries::points() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.toList();
             }
             /*!
                 Returns point at \a index in internal points vector.
             */
             const QPointF &QXYSeries::at(int index) const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.at(index);
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.count();
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen != pen) {
                     bool emitColorChanged = d->m_pen.color() != pen.color();
                     d->m_pen = pen;
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(pen.color());
                 }
             }
             QPen QXYSeries::pen() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QXYSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QXYSeries::brush() const
             {
                 Q_D(const QXYSeries);
                 return d->m_brush;
             }
             void QXYSeries::setColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QXYSeries::color() const
             {
                 return pen().color();
             }
             void QXYSeries::setPointsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             bool QXYSeries::pointsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointsVisible;
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa append()
             */
             QXYSeries &QXYSeries::operator<< (const QPointF &point)
             {
                 append(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa append()
             */
             QXYSeries &QXYSeries::operator<< (const QList<QPointF>& points)
             {
                 append(points);
                 return *this;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q)
                 : QAbstractSeriesPrivate(q),
                   m_pointsVisible(false)
             {
             }
             void QXYSeriesPrivate::initializeDomain()
             {
                 qreal minX(0);
                 qreal minY(0);
                 qreal maxX(1);
                 qreal maxY(1);
                 Q_Q(QXYSeries);
                 const QList<QPointF>& points = q->points();
                 if (!points.isEmpty()) {
                     minX = points[0].x();
                     minY = points[0].y();
                     maxX = minX;
                     maxY = minY;
                     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);
             }
             QList<QLegendMarker*> QXYSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<QLegendMarker*> list;
                 return list << new QXYLegendMarker(q,legend);
             }
             void QXYSeriesPrivate::initializeAxes()
             {
             }
             QAbstractAxis::AxisType QXYSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValue;
             }
             QAbstractAxis* QXYSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return 0;
             }
             void QXYSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
             {
                 XYChart *item = static_cast<XYChart *>(m_item.data());
                 Q_ASSERT(item);
                 if (options.testFlag(QChart::SeriesAnimations)) {
                     item->setAnimation(new XYAnimation(item));
                 }else{
                     item->setAnimation(0);
                 }
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

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

No TODOs yet

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

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