HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1491:abdb70920d73

Documenting xy-series

Tero Ahola -

r1491:abdb70920d73

parent child

Context file:

r1491:abdb70920d73

Collapse all files

doc/src/qml.qdoc 0 -5

             /*!
                 \page qml.html
                 \title QtCommercial Charts QML API
                 \keyword Charts QML API
                 QtCommercial Charts QML API is an intuitive and simple way to show charts in your QML
                 applications. The following QML shows you to create a simple pie chart:
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 1
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 2
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 3
-                \beginfloatleft
-                \image examples_qmlpiechart.png
-                \endfloat
-                \clearfloat
                 \raw HTML
                     <table cellpadding="2" cellspacing="1" border="0" width="95%" class="indextable">
                         <tr>
                             <th class="titleheader" width="25%"> ChartView and it's properties </th>
                         </tr>
                         <tr>
                             <td valign="top">
                                 <ul>
                                 <li><a href="qml-chartview.html">ChartView</a></li>
                                 <li><a href="qml-axis.html">Axis</a></li>
                                 <li><a href="qml-legend.html">Legend</a></li>
                                 </ul>
                             </td>
                         </tr>
                     </table>
                     <table cellpadding="2" cellspacing="1" border="0" width="95%" class="indextable">
                         <tr>
                             <th class="titleheader" width="25%"> XY chart </th>
                         </tr>
                         <tr>
                             <td valign="top">
                                 <ul>
                                 <li><a href="qml-lineseries.html">LineSeries</a></li>
                                 <li><a href="qml-areaseries.html">AreaSeries</a></li>
                                 <li><a href="qml-scatterseries.html">ScatterSeries</a></li>
                                 <li><a href="qml-splineseries.html">SplineSeries</a></li>
                                 <li><a href="qml-xypoint.html">XyPoint</a></li>
                                 </ul>
                             </td>
                         </tr>
                     </table>
                     <table cellpadding="2" cellspacing="1" border="0" width="95%" class="indextable">
                         <tr>
                             <th class="titleheader" width="25%"> Pie chart </th>
                         <tr>
                             <td valign="top">
                                 <ul>
                                 <li><a href="qml-pieseries.html">PieSeries</a></li>
                                 <li><a href="qml-pieslice.html">PieSlice</a></li>
                                 </ul>
                             </td>
                         </tr>
                     </table>
                     <table cellpadding="2" cellspacing="1" border="0" width="95%" class="indextable">
                         <tr>
                             <th class="titleheader" width="25%"> Bar chart </th>
                         <tr>
                             <td valign="top">
                                 <ul>
                                 <li><a href="qml-barseries.html">BarSeries</a></li>
                                 <li><a href="qml-groupedbarseries.html">GroupedBarSeries</a></li>
                                 <li><a href="qml-stackedbarseries.html">StackedBarSeries</a></li>
                                 <li><a href="qml-percentbarseries.html">PercentBarSeries</a></li>
                                 <li><a href="qml-barset.html">BarSet</a></li>
                                 </ul>
                             </td>
                         </tr>
                     </table>
                 \endraw
             */

plugins/declarative/declarativeareaseries.cpp 0 -14

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativeareaseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
             #include "qxymodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            /*!
-                \qmlclass AreaSeries QAreaSeries
-                \section1 Example Usage
-                \beginfloatleft
-                \image demos_qmlchart4.png
-                \endfloat
-                \clearfloat
-                The following QML shows how to create a simple area chart:
-                \snippet ../demos/qmlchart/qml/qmlchart/View4.qml 1
-            */
             DeclarativeAreaSeries::DeclarativeAreaSeries(QObject *parent) :
                 QAreaSeries(parent)
             {
             }
             void DeclarativeAreaSeries::setUpperSeries(DeclarativeLineSeries* series)
             {
                 QAreaSeries::setUpperSeries(series);
             }
             DeclarativeLineSeries* DeclarativeAreaSeries::upperSeries() const
             {
                 return qobject_cast<DeclarativeLineSeries *>(QAreaSeries::upperSeries());
             }
             void DeclarativeAreaSeries::setLowerSeries(DeclarativeLineSeries* series)
             {
                 QAreaSeries::setLowerSeries(series);
             }
             DeclarativeLineSeries* DeclarativeAreaSeries::lowerSeries() const
             {
                 return qobject_cast<DeclarativeLineSeries *>(QAreaSeries::lowerSeries());
             }
             #include "moc_declarativeareaseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativechart.cpp +5 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativechart.h"
             #include <QPainter>
             #include "declarativelineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "declarativesplineseries.h"
             #include "declarativescatterseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \qmlclass ChartView DeclarativeChart
                 ChartView element is the parent that is responsible for showing different chart series types.
-                The following QML shows how to create a simple line chart:
+                The following QML shows how to create a simple chart with one pie series:
-                \snippet ../demos/qmlchart/qml/qmlchart/View2.qml 1
+                \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 1
+                \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 2
+                \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 3
                 \beginfloatleft
-                \image demos_qmlchart2.png
+                \image examples_qmlpiechart.png
                 \endfloat
                 \clearfloat
             */
             /*!
               \qmlproperty Theme ChartView::theme
               Theme defines the visual appearance of the chart, including for example colors, fonts, line
               widths and chart background.
             */
             /*!
               \qmlproperty Animation ChartView::animation
               Animation configuration of the chart. One of ChartView.NoAnimation, ChartView.GridAxisAnimations,
               ChartView.SeriesAnimations or ChartView.AllAnimations.
             */
             /*!
               \qmlproperty string ChartView::title
               The title of the chart, shown on top of the chart.
               \sa ChartView::titleColor
             */
             /*!
               \qmlproperty string ChartView::titleColor
               The color of the title text.
             */
             /*!
               \qmlproperty Axis ChartView::axisX
               The x-axis of the chart.
             */
             /*!
               \qmlproperty Axis ChartView::axisY
               The default y-axis of the chart.
             */
             /*!
               \qmlproperty Legend ChartView::legend
               The legend of the chart. Legend lists all the series, pie slices and bar sets added on the chart.
             */
             /*!
               \qmlproperty int ChartView::count
               The count of series added to the chart.
             */
             /*!
               \qmlproperty color ChartView::backgroundColor
               The color of the chart's background. By default background color is defined by chart theme.
               \sa ChartView::theme
             */
             /*!
               \qmlproperty bool ChartView::dropShadowEnabled
               The chart's border drop shadow. Set to true to enable drop shadow.
             */
             /*!
               \qmlmethod Axis ChartView::axisY(QAbstractSeries *series)
               The y-axis of the series. This is the same as the default y-axis of the chart, unless you have
               explicitly defined the series to have a non-default y-axis.
             */
             DeclarativeChart::DeclarativeChart(QDeclarativeItem *parent)
                 : QDeclarativeItem(parent),
                   m_chart(new QChart(this))
             {
                 setFlag(QGraphicsItem::ItemHasNoContents, false);
             //    m_chart->axisX()->setNiceNumbersEnabled(false);
             }
             DeclarativeChart::~DeclarativeChart()
             {
                 delete m_chart;
             }
             void DeclarativeChart::childEvent(QChildEvent *event)
             {
                 if (event->type() == QEvent::ChildAdded) {
                     if (qobject_cast<QAbstractSeries *>(event->child())) {
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(event->child()));
                     }
                 }
             }
             void DeclarativeChart::componentComplete()
             {
                 foreach(QObject *child, children()) {
                     if (qobject_cast<QAbstractSeries *>(child)) {
             //            qDebug() << "DeclarativeChart::componentComplete(), add: " << child;
                         // TODO: how about optional y-axis?
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(child));
                     }
                 }
                 QDeclarativeItem::componentComplete();
             }
             void DeclarativeChart::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
             {
             //    qDebug() << "DeclarativeChart::geometryChanged" << newGeometry.width() << newGeometry.height();
                 if (newGeometry.isValid()) {
                     if (newGeometry.width() > 0 && newGeometry.height() > 0) {
                         m_chart->resize(newGeometry.width(), newGeometry.height());
                     }
                 }
                 QDeclarativeItem::geometryChanged(newGeometry, oldGeometry);
             }
             void DeclarativeChart::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 // TODO: optimized?
                 painter->setRenderHint(QPainter::Antialiasing, true);
             }
             void DeclarativeChart::setTheme(DeclarativeChart::Theme theme)
             {
                 QChart::ChartTheme chartTheme = (QChart::ChartTheme) theme;
                 if (chartTheme != m_chart->theme())
                     m_chart->setTheme(chartTheme);
             }
             DeclarativeChart::Theme DeclarativeChart::theme()
             {
                 return (DeclarativeChart::Theme) m_chart->theme();
             }
             void DeclarativeChart::setAnimationOptions(DeclarativeChart::Animation animations)
             {
                 QChart::AnimationOption animationOptions = (QChart::AnimationOption) animations;
                 if (animationOptions != m_chart->animationOptions())
                     m_chart->setAnimationOptions(animationOptions);
             }
             DeclarativeChart::Animation DeclarativeChart::animationOptions()
             {
                 if (m_chart->animationOptions().testFlag(QChart::AllAnimations))
                     return DeclarativeChart::AllAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::GridAxisAnimations))
                     return DeclarativeChart::GridAxisAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::SeriesAnimations))
                     return DeclarativeChart::SeriesAnimations;
                 else
                     return DeclarativeChart::NoAnimation;
             }
             void DeclarativeChart::setTitle(QString title)
             {
                 if (title != m_chart->title())
                     m_chart->setTitle(title);
             }
             QString DeclarativeChart::title()
             {
                 return m_chart->title();
             }
             QAxis *DeclarativeChart::axisX()
             {
                 return m_chart->axisX();
             }
             QAxis *DeclarativeChart::axisY(QAbstractSeries *series)
             {
                 return m_chart->axisY(series);
             }
             QLegend *DeclarativeChart::legend()
             {
                 return m_chart->legend();
             }
             QVariantList DeclarativeChart::axisXLabels()
             {
                 QVariantList labels;
                 foreach (qreal value, m_chart->axisX()->categories()->values()) {
                     labels.append(value);
                     labels.append(m_chart->axisX()->categories()->label(value));
                 }
                 return labels;
             }
             void DeclarativeChart::setAxisXLabels(QVariantList list)
             {
                 QVariant value(QVariant::Invalid);
                 foreach (QVariant element, list) {
                     if (value.isValid() && element.type() == QVariant::String) {
                         m_chart->axisX()->categories()->insert(value.toDouble(), element.toString());
                         value = QVariant(QVariant::Invalid);
                     } else {
                         if (element.canConvert(QVariant::Double))
                             value = element;
                     }
                 }
                 emit axisLabelsChanged();
             }
             void DeclarativeChart::setTitleColor(QColor color)
             {
                 QBrush b = m_chart->titleBrush();
                 if (color != b.color()) {
                     b.setColor(color);
                     m_chart->setTitleBrush(b);
                     emit titleColorChanged();
                 }
             }
             QColor DeclarativeChart::titleColor()
             {
                 return m_chart->titleBrush().color();
             }
             void DeclarativeChart::setBackgroundColor(QColor color)
             {
                 QBrush b = m_chart->backgroundBrush();
                 if (b.style() != Qt::SolidPattern || color != b.color()) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setBackgroundBrush(b);
                     emit backgroundColorChanged();
                 }
             }
             QColor DeclarativeChart::backgroundColor()
             {
                 return m_chart->backgroundBrush().color();
             }
             int DeclarativeChart::count()
             {
                 return m_chart->series().count();
             }
             void DeclarativeChart::setDropShadowEnabled(bool enabled)
             {
                 if (enabled != m_chart->isDropShadowEnabled()) {
                     m_chart->setDropShadowEnabled(enabled);
                     dropShadowEnabledChanged(enabled);
                 }
             }
             bool DeclarativeChart::dropShadowEnabled()
             {
                 return m_chart->isDropShadowEnabled();
             }
             void DeclarativeChart::zoom(qreal factor)
             {
                 m_chart->zoom(factor);
             }
             void DeclarativeChart::scrollLeft(qreal pixels)
             {
                 m_chart->scroll(QPointF(pixels, 0));
             }
             void DeclarativeChart::scrollRight(qreal pixels)
             {
                 m_chart->scroll(QPointF(-pixels, 0));
             }
             void DeclarativeChart::scrollUp(qreal pixels)
             {
                 m_chart->scroll(QPointF(0, pixels));
             }
             void DeclarativeChart::scrollDown(qreal pixels)
             {
                 m_chart->scroll(QPointF(0, -pixels));
             }
             QAbstractSeries *DeclarativeChart::series(int index)
             {
                 if (index < m_chart->series().count()) {
                     return m_chart->series().at(index);
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::series(QString seriesName)
             {
                 foreach(QAbstractSeries *series, m_chart->series()) {
                     if (series->name() == seriesName)
                         return series;
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::createSeries(DeclarativeChart::SeriesType type, QString name)
             {
                 QAbstractSeries *series = 0;
                 switch (type) {
                 case DeclarativeChart::SeriesTypeLine:
                     series = new DeclarativeLineSeries();
                     break;
                 case DeclarativeChart::SeriesTypeArea:
                     series = new DeclarativeAreaSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBar:
                     series = new DeclarativeBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeStackedBar:
                     // TODO
                     break;
                 case DeclarativeChart::SeriesTypePercentBar:
                     // TODO
                     break;
                 case DeclarativeChart::SeriesTypeGroupedBar:
                     series = new DeclarativeGroupedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypePie:
                     series = new DeclarativePieSeries();
                     break;
                 case DeclarativeChart::SeriesTypeScatter:
                     series = new DeclarativeScatterSeries();
                     break;
                 case DeclarativeChart::SeriesTypeSpline:
                     series = new DeclarativeSplineSeries();
                     break;
                 default:
                     qWarning() << "Illegal series type";
                 }
                 series->setName(name);
                 m_chart->addSeries(series);
                 return series;
             }
             #include "moc_declarativechart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativelineseries.cpp 0 -12

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativelineseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
             #include "qlineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            /*!
-                \qmlclass LineSeries QLineSeries
-                \beginfloatleft
-                \image demos_qmlchart2.png
-                \endfloat
-                \clearfloat
-                The following QML shows how to create a simple line chart:
-                \snippet ../demos/qmlchart/qml/qmlchart/View2.qml 1
-            */
             DeclarativeLineSeries::DeclarativeLineSeries(QObject *parent) :
                 QLineSeries(parent)
             {
                 connect(this, SIGNAL(pointAdded(int)), this, SLOT(handleCountChanged(int)));
                 connect(this, SIGNAL(pointRemoved(int)), this, SLOT(handleCountChanged(int)));
             }
             QXYSeries *DeclarativeLineSeries::xySeries()
             {
                 return this;
             }
             void DeclarativeLineSeries::handleCountChanged(int index)
             {
                 Q_UNUSED(index)
                 emit countChanged(points().count());
             }
             QDeclarativeListProperty<QObject> DeclarativeLineSeries::declarativeChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &appendDeclarativeChildren);
             }
             void DeclarativeLineSeries::appendDeclarativeChildren(QDeclarativeListProperty<QObject> *list, QObject *element)
             {
                 Q_UNUSED(list)
                 Q_UNUSED(element)
                 // Empty implementation, childs are parsed in componentComplete
             }
             #include "moc_declarativelineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativepieseries.cpp 0 -47

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativepieseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
             #include <qdeclarativelist.h>
             #include <QVPieModelMapper>
             #include <QHPieModelMapper>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            /*!
-                \qmlclass PieSeries QPieSeries
-                \section1 Example Usage
-                \beginfloatleft
-                \image demos_qmlchart1.png
-                \endfloat
-                \clearfloat
-                The following QML shows how to create a simple pie chart.
-                \snippet ../demos/qmlchart/qml/qmlchart/View1.qml 1
-            */
-            /*!
-                \qmlproperty real PieSeries::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::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
-            */
             DeclarativePieSeries::DeclarativePieSeries(QObject *parent) :
                 QPieSeries(parent)
             {
             }
             void DeclarativePieSeries::classBegin()
             {
             }
             void DeclarativePieSeries::componentComplete()
             {
                 foreach(QObject *child, children()) {
                     if (qobject_cast<QPieSlice *>(child)) {
                         QPieSeries::append(qobject_cast<QPieSlice *>(child));
                     } else if(qobject_cast<QVPieModelMapper *>(child)) {
                         QVPieModelMapper *mapper = qobject_cast<QVPieModelMapper *>(child);
                         mapper->setSeries(this);
                     } else if(qobject_cast<QHPieModelMapper *>(child)) {
                         QHPieModelMapper *mapper = qobject_cast<QHPieModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             QDeclarativeListProperty<QObject> DeclarativePieSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativePieSeries::appendSeriesChildren);
             }
             void DeclarativePieSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             QPieSlice *DeclarativePieSeries::at(int index)
             {
                 QList<QPieSlice*> sliceList = slices();
                 if (index < sliceList.count())
                     return sliceList[index];
                 return 0;
             }
             QPieSlice* DeclarativePieSeries::find(QString label)
             {
                 foreach (QPieSlice *slice, slices()) {
                     if (slice->label() == label)
                         return slice;
                 }
                 return 0;
             }
             QPieSlice* DeclarativePieSeries::append(QString label, qreal value)
             {
                 // TODO: parameter order is wrong, switch it:
                 QPieSlice *slice = new QPieSlice(this);
                 slice->setLabel(label);
                 slice->setValue(value);
                 QPieSeries::append(slice);
                 return slice;
             }
             #include "moc_declarativepieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativescatterseries.cpp 0 -13

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativescatterseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
             #include "qscatterseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            /*!
-                \qmlclass ScatterSeries QScatterSeries
-                The following QML shows how to create a chart with two simple scatter series:
-                \snippet ../demos/qmlchart/qml/qmlchart/View5.qml 1
-                \snippet ../demos/qmlchart/qml/qmlchart/View5.qml 2
-                \beginfloatleft
-                \image demos_qmlchart5.png
-                \endfloat
-                \clearfloat
-            */
             DeclarativeScatterSeries::DeclarativeScatterSeries(QObject *parent) :
                 QScatterSeries(parent)
             {
                 connect(this, SIGNAL(pointAdded(int)), this, SLOT(handleCountChanged(int)));
                 connect(this, SIGNAL(pointRemoved(int)), this, SLOT(handleCountChanged(int)));
             }
             QXYSeries *DeclarativeScatterSeries::xySeries()
             {
                 return this;
             }
             void DeclarativeScatterSeries::handleCountChanged(int index)
             {
                 Q_UNUSED(index)
                 emit countChanged(QScatterSeries::count());
             }
             QDeclarativeListProperty<QObject> DeclarativeScatterSeries::declarativeChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &appendDeclarativeChildren);
             }
             void DeclarativeScatterSeries::appendDeclarativeChildren(QDeclarativeListProperty<QObject> *list, QObject *element)
             {
                 Q_UNUSED(list)
                 Q_UNUSED(element)
                 // Empty implementation, childs are parsed in componentComplete
             }
             #include "moc_declarativescatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativesplineseries.cpp 0 -14

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativesplineseries.h"
             #include "declarativechart.h"
             #include <QChart>
             #include "declarativexypoint.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            /*!
-                \qmlclass SplineSeries QSplineSeries
-                \section1 Example Usage
-                \beginfloatleft
-                \image demos_qmlchart3.png
-                \endfloat
-                \clearfloat
-                The following QML shows how to create a simple spline chart:
-                \snippet ../demos/qmlchart/qml/qmlchart/View3.qml 1
-            */
             DeclarativeSplineSeries::DeclarativeSplineSeries(QObject *parent) :
                 QSplineSeries(parent)
             {
                 connect(this, SIGNAL(pointAdded(int)), this, SLOT(handleCountChanged(int)));
                 connect(this, SIGNAL(pointRemoved(int)), this, SLOT(handleCountChanged(int)));
             }
             QXYSeries *DeclarativeSplineSeries::xySeries()
             {
                 return this;
             }
             void DeclarativeSplineSeries::handleCountChanged(int index)
             {
                 Q_UNUSED(index)
                 emit countChanged(points().count());
             }
             QDeclarativeListProperty<QObject> DeclarativeSplineSeries::declarativeChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &appendDeclarativeChildren);
             }
             void DeclarativeSplineSeries::appendDeclarativeChildren(QDeclarativeListProperty<QObject> *list, QObject *element)
             {
                 Q_UNUSED(list)
                 Q_UNUSED(element)
                 // Empty implementation, childs are parsed in componentComplete
             }
             #include "moc_declarativesplineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativexypoint.cpp +17 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativexypoint.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            /*!
+                \qmlclass XyPoint QPointF
+                XyPoint is a convenience element for initializing XY-series with static coordinate data. To
+                manipulate an XY-series dynamically, use it's data manipulation functions instead.
+                \sa LineSeries, AreaSeries, ScatterSeries, SplineSeries
+            */
+            /*!
+                \qmlproperty real XyPoint::x
+                The x-coordinate of the point.
+            */
+            /*!
+                \qmlproperty real XyPoint::y
+                The y-coordinate of the point.
+            */
             DeclarativeXyPoint::DeclarativeXyPoint(QObject *parent) :
                 QObject(parent)
             {
                 setX(0.0);
                 setY(0.0);
             }
             #include "moc_declarativexypoint.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/plugin.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtDeclarative/qdeclarativeextensionplugin.h>
             #include <QtDeclarative/qdeclarative.h>
             #include "qchart.h"
             #include "qaxiscategories.h"
             #include "declarativechart.h"
             #include "declarativexypoint.h"
             #include "declarativelineseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativescatterseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include <QVXYModelMapper>
             #include <QHXYModelMapper>
             #include <QHPieModelMapper>
             #include <QVPieModelMapper>
             #include <QHBarModelMapper>
             #include <QVBarModelMapper>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartQmlPlugin : public QDeclarativeExtensionPlugin
             {
                 Q_OBJECT
             public:
                 virtual void registerTypes(const char *uri)
                 {
                     Q_ASSERT(QLatin1String(uri) == QLatin1String("QtCommercial.Chart"));
                     qmlRegisterType<DeclarativeChart>(uri, 1, 0, "ChartView");
                     qmlRegisterType<DeclarativeXyPoint>(uri, 1, 0, "XyPoint");
                     qmlRegisterType<DeclarativeScatterSeries>(uri, 1, 0, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries>(uri, 1, 0, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries>(uri, 1, 0, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries>(uri, 1, 0, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries>(uri, 1, 0, "BarSeries");
                     qmlRegisterType<DeclarativeGroupedBarSeries>(uri, 1, 0, "GroupedBarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries>(uri, 1, 0, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries>(uri, 1, 0, "PercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 0, "PieSeries");
                     qmlRegisterType<QPieSlice>(uri, 1, 0, "PieSlice");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 0, "BarSet");
                     qmlRegisterType<QHXYModelMapper>(uri, 1, 0, "HXYModelMapper");
                     qmlRegisterType<QVXYModelMapper>(uri, 1, 0, "VXYModelMapper");
                     qmlRegisterType<QHPieModelMapper>(uri, 1, 0, "HPieModelMapper");
                     qmlRegisterType<QVPieModelMapper>(uri, 1, 0, "VPieModelMapper");
                     qmlRegisterType<QHBarModelMapper>(uri, 1, 0, "HBarModelMapper");
                     qmlRegisterType<QVBarModelMapper>(uri, 1, 0, "VBarModelMapper");
                     qmlRegisterUncreatableType<QLegend>(uri, 1, 0, "Legend",
                                                       QLatin1String("Trying to create uncreatable: Legend."));
-                    qmlRegisterUncreatableType<QXYSeries>(uri, 1, 0, "QXYSeries",
+                    qmlRegisterUncreatableType<QXYSeries>(uri, 1, 0, "XYSeries",
-                                                      QLatin1String("Trying to create uncreatable: QXYSeries."));
+                                                      QLatin1String("Trying to create uncreatable: XYSeries."));
                     qmlRegisterUncreatableType<QScatterSeries>(uri, 1, 0, "QScatterSeries",
                                                       QLatin1String("Trying to create uncreatable: QScatterSeries."));
                     qmlRegisterUncreatableType<QPieSeries>(uri, 1, 0, "QPieSeries",
                                                       QLatin1String("Trying to create uncreatable: QPieSeries."));
                     qmlRegisterUncreatableType<QBarSet>(uri, 1, 0, "QBarSet",
                                                       QLatin1String("Trying to create uncreatable: QBarSet."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 0, "AbstractItemModel",
                                                       QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
                                                       QLatin1String("Trying to create uncreatable: XYModelMapper."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                       QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QBarModelMapper>(uri, 1, 0, "BarModelMapper",
                                                       QLatin1String("Trying to create uncreatable: BarModelMapper."));
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 1, 0, "AbstractSeries",
                                                       QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAxis>(uri, 1, 0, "Axis",
                                                       QLatin1String("Trying to create uncreatable: Axis."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: XYModelMapper."));
                 }
             };
             #include "plugin.moc"
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_EXPORT_PLUGIN2(qtcommercialchartqml, QT_PREPEND_NAMESPACE(ChartQmlPlugin))

src/areachart/qareaseries.cpp +46 -5

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qareaseries.h"
             #include "qareaseries_p.h"
             #include "qlineseries.h"
             #include "areachartitem_p.h"
             #include "legendmarker_p.h"
             #include "domain_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAreaSeries
                 \brief The QAreaSeries class is used for making area charts.
                 \mainclass
             	An area chart is used to show quantitative data. It is based on line chart, in the way that area between axis and the line
             	is emphasized with color. Since the area chart is based on line chart, QAreaSeries constructor needs QLineSeries instance,
             	which defines "upper" boundary of the area. "Lower" boundary is defined by default by axis X. Instead of axis X "lower" boundary can be specified by other line.
             	In that case QAreaSeries should be initiated with two QLineSerie instances. Please note terms "upper" and "lower" boundary can be misleading in cases
             	where "lower" boundary had bigger values than the "upper" one, however the main point that area between these two boundary lines will be filled.
                 See the \l {AreaChart Example} {area chart example} to learn how to create a simple area chart.
                 \image examples_areachart.png
             */
+            /*!
+                \qmlclass AreaSeries QAreaSeries
+                The following QML shows how to create a simple area chart:
+                \snippet ../demos/qmlchart/qml/qmlchart/View4.qml 1
+                \beginfloatleft
+                \image demos_qmlchart4.png
+                \endfloat
+                \clearfloat
+            */
             /*!
                \property QAreaSeries::upperSeries
                \brief The upper one of the two line series used to define area series boundaries.
             */
+            /*!
+               \qmlproperty LineSeries AreaSeries::upperSeries
+               The upper one of the two line series used to define area series boundaries.
+            */
             /*!
                 \property QAreaSeries::lowerSeries
                 The lower one of the two line series used to define are series boundaries. Note if
                 QAreaSeries was counstucted wihtout a\ lowerSeries this is null.
             */
+            /*!
+                \qmlproperty LineSeries AreaSeries::lowerSeries
+                The lower one of the two line series used to define are series boundaries. Note if
+                AreaSeries was counstucted wihtout a\ lowerSeries this is null.
+            */
             /*!
                 \property QAreaSeries::color
                 Fill (brush) color of the series. This is a convenience property for modifying the color of brush.
                 \sa QAreaSeries::brush()
             */
+            /*!
+                \qmlproperty color AreaSeries::color
+                Fill (brush) color of the series.
+            */
             /*!
                 \property QAreaSeries::borderColor
                 Line (pen) color of the series. This is a convenience property for modifying the color of pen.
                 \sa QAreaSeries::pen()
             */
+            /*!
+                \qmlproperty color AreaSeries::borderColor
+                Line (pen) color of the series.
+            */
             /*!
                \fn QPen QAreaSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn QPen QAreaSeries::brush() const
                \brief  Returns the brush used to draw line for this series.
                 \sa setBrush()
             */
             /*!
                 \fn void QAreaSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the fill (brush) color has changed to \a color.
             */
+            /*!
+                \qmlsignal AreaSeries::colorChanged(color color)
+                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.
             */
             /*!
-               \fn bool  QAreaSeries::pointsVisible() const
+                \qmlsignal AreaSeries::borderColorChanged(color color)
-               \brief  Returns if the points are drawn for this series.
+                Signal is emitted when the line (pen) color has changed to \a color.
-                \sa setPointsVisible()
             */
             /*!
                 \fn void QAreaSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on area chart.
             */
+            /*!
+                \qmlsignal AreaSeries::clicked(QPointF point)
+                Signal is emitted when user clicks the \a point on area chart.
+            */
             /*!
                 \fn void QAreaSeries::selected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of QAreaSeries API.
             */
+            /*!
+                \qmlsignal AreaSeries::selected()
+                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. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QAreaSeries::~QAreaSeries()
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypeArea.
             */
             QAbstractSeries::SeriesType QAreaSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeArea;
             }
             /*!
                 Sets the \a series that is to be used as the area chart upper series.
             */
             void QAreaSeries::setUpperSeries(QLineSeries* series)
             {
                 Q_D(QAreaSeries);
                 d->m_upperSeries = series;
             }
             QLineSeries* QAreaSeries::upperSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_upperSeries;
             }
             /*!
                 Sets the \a series that is to be used as the area chart lower series.
             */
             void QAreaSeries::setLowerSeries(QLineSeries* series)
             {
                 Q_D(QAreaSeries);
                 d->m_lowerSeries = series;
             }
             QLineSeries* QAreaSeries::lowerSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_lowerSeries;
             }
             /*!
                 Sets \a pen used for drawing area outline.
             */
             void QAreaSeries::setPen(const QPen &pen)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pen != pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen  QAreaSeries::pen() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for filling the area.
             */
             void QAreaSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QAreaSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QAreaSeries::brush() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_brush;
             }
             void QAreaSeries::setColor(const QColor &color)
             {
                 QBrush b = brush();
                 if (b.color() != color) {
                     b.setColor(color);
                     setBrush(b);
                     emit colorChanged(color);
                 }
             }
             QColor QAreaSeries::color() const
             {
                 return brush().color();
             }
             void QAreaSeries::setBorderColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             QColor QAreaSeries::borderColor() const
             {
                 return pen().color();
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QAreaSeries::setPointsVisible(bool visible)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
+            /*!
+                Returns if the points are drawn for this series.
+                \sa setPointsVisible()
+            */
             bool QAreaSeries::pointsVisible() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointsVisible;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries,QAreaSeries* q) :
                 QAbstractSeriesPrivate(q),
                 m_upperSeries(upperSeries),
                 m_lowerSeries(lowerSeries),
                 m_pointsVisible(false)
             {
             }
             void QAreaSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_Q(QAreaSeries);
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 QLineSeries* upperSeries = q->upperSeries();
                 QLineSeries* lowerSeries = q->lowerSeries();
                 const QList<QPointF>& points = upperSeries->points();
                 for (int i = 0; i < points.count(); i++)
                 {
                     qreal x = points[i].x();
                     qreal y = points[i].y();
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                 if(lowerSeries) {
                     const QList<QPointF>& points = lowerSeries->points();
                     for (int i = 0; i < points.count(); i++)
                     {
                         qreal x = points[i].x();
                         qreal y = points[i].y();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                     }}
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QAreaSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem* area = new AreaChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     area->upperLineItem()->setAnimator(presenter->animator());
                     area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem()));
                     if(q->lowerSeries())  {
                         area->lowerLineItem()->setAnimator(presenter->animator());
                         area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem()));
                     }
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return area;
             }
             QList<LegendMarker*> QAreaSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QAreaSeries);
                 QList<LegendMarker*> list;
                 return list << new AreaLegendMarker(q,legend);
             }
             #include "moc_qareaseries.cpp"
             #include "moc_qareaseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/qlineseries.cpp +11 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qlineseries.h"
             #include "qlineseries_p.h"
             #include "linechartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLineSeries
                 \brief The QLineSeries class is used for making line charts.
                 \mainclass
             	A line chart is used to show information as a series of data points
             	connected by straight lines.
                 \image examples_linechart.png
             	Creating basic line chart is simple:
             	\code
                 QLineSeries* series = new QLineSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chart->addSeries(series);
                 \endcode
             */
+            /*!
+                \qmlclass LineSeries QLineSeries
+                \inherits XYSeries
+                The following QML shows how to create a simple line chart:
+                \snippet ../demos/qmlchart/qml/qmlchart/View2.qml 1
+                \beginfloatleft
+                \image demos_qmlchart2.png
+                \endfloat
+                \clearfloat
+            */
             /*!
                 \fn virtual SeriesType QLineSeries::type() const
                 \brief Returns type of series.
                 \sa QAbstractSeries, SeriesType
             */
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QLineSeries::QLineSeries(QObject *parent) : QXYSeries(*new QLineSeriesPrivate(this),parent)
             {
             }
             /*!
                 \internal
             */
             QLineSeries::QLineSeries(QLineSeriesPrivate &d,QObject *parent) : QXYSeries (d,parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QLineSeries::~QLineSeries()
             {
                 Q_D(QLineSeries);
                 if(d->m_dataset){
                        d->m_dataset->removeSeries(this);
                 }
             }
             QAbstractSeries::SeriesType QLineSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeLine;
             }
             /*
             QDebug operator<< (QDebug debug, const QLineSeries series)
             {
                 Q_ASSERT(series.d_func()->m_x.size() == series.d_func()->m_y.size());
                 int size = series.d_func()->m_x.size();
                 for (int i=0; i<size; i++) {
                     debug.nospace() << "(" << series.d_func()->m_x.at(i) << ','<< series.d_func()->m_y.at(i) << ") ";
                 }
                 return debug.space();
             }
             */
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLineSeriesPrivate::QLineSeriesPrivate(QLineSeries* q):QXYSeriesPrivate(q)
             {
             };
             Chart* QLineSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QLineSeries);
                 LineChartItem* line = new LineChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     line->setAnimator(presenter->animator());
                     line->setAnimation(new XYAnimation(line));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return line;
             }
             #include "moc_qlineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.cpp +30 -8

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

src/scatterchart/qscatterseries.cpp +30 -5

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "scatterchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             /*!
                 \class QScatterSeries
                 \brief The QScatterSeries class is used for making scatter charts.
                 \mainclass
                 The scatter data is displayed as a collection of points on the chart. Each point determines the position on the horizontal axis
                 and the vertical axis.
                 \image examples_scatterchart.png
                 Creating basic scatter chart is simple:
                 \code
                 QScatterSeries* series = new QScatterSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chart->addSeries(series);
                 \endcode
             */
+            /*!
+                \qmlclass ScatterSeries QScatterSeries
+                \inherits XYSeries
+                The following QML shows how to create a chart with two simple scatter series:
+                \snippet ../demos/qmlchart/qml/qmlchart/View5.qml 1
+                \snippet ../demos/qmlchart/qml/qmlchart/View5.qml 2
+                \beginfloatleft
+                \image demos_qmlchart5.png
+                \endfloat
+                \clearfloat
+            */
             /*!
                 \enum QScatterSeries::MarkerShape
                 This enum describes the shape used when rendering marker items.
                 \value MarkerShapeCircle
                 \value MarkerShapeRectangle
             */
             /*!
                 \property QScatterSeries::color
                 Fill (brush) color of the series. This is a convenience property for modifying the color of brush.
                 \sa QScatterSeries::brush()
             */
             /*!
                 \property QScatterSeries::borderColor
                 Line (pen) color of the series. This is a convenience property for modifying the color of pen.
                 \sa QScatterSeries::pen()
             */
             /*!
                 \property QScatterSeries::markerShape
                 Defines the shape of the marker used to draw the points in the series. The default shape is MarkerShapeCircle.
             */
+            /*!
+                \qmlproperty MarkerShape ScatterSeries::markerShape
+                Defines the shape of the marker used to draw the points in the series. One of ScatterSeries
+                ScatterSeries.MarkerShapeCircle or ScatterSeries.MarkerShapeRectangle.
+                The default shape is ScatterSeries.MarkerShapeCircle.
+            */
             /*!
                 \property QScatterSeries::markerSize
+                Defines the size of the marker used to draw the points in the series. The default size is 15.0.
+            */
+            /*!
+                \qmlproperty real ScatterSeries::markerSize
                 Defines the size of the marker used to draw the points in the series. The default size is 15.0.
             */
             /*!
                 \fn void QScatterSeries::colorChanged(QColor color)
-                \brief Signal is emitted when the fill (brush) color has changed to \a color.
+                Signal is emitted when the fill (brush) color has changed to \a color.
             */
             /*!
                 \fn void QScatterSeries::borderColorChanged(QColor color)
-                \brief Signal is emitted when the line (pen) color has changed to \a color.
+                Signal is emitted when the line (pen) color has changed to \a color.
+            */
+            /*!
+                \qmlsignal ScatterSeries::borderColorChanged(color color)
+                Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn QChartSeriesType QScatterSeries::type() const
-                \brief Returns QChartSeries::SeriesTypeScatter.
+                Returns QChartSeries::SeriesTypeScatter.
                 \sa QAbstractSeries, SeriesType
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QScatterSeries::QScatterSeries(QObject *parent) : QXYSeries(*new QScatterSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QScatterSeries::~QScatterSeries()
             {
                 Q_D(QScatterSeries);
                 if(d->m_dataset) {
                     d->m_dataset->removeSeries(this);
                 }
             }
             QAbstractSeries::SeriesType QScatterSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeScatter;
             }
             void QScatterSeries::setColor(const QColor &color)
             {
                 QBrush b = brush();
                 if (b.color() != color) {
                     b.setColor(color);
                     setBrush(b);
                     emit colorChanged(color);
                 }
             }
             QColor QScatterSeries::color() const
             {
                 return brush().color();
             }
             void QScatterSeries::setBorderColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             QColor QScatterSeries::borderColor() const
             {
                 return pen().color();
             }
             QScatterSeries::MarkerShape QScatterSeries::markerShape() const
             {
                 Q_D(const QScatterSeries);
                 return d->m_shape;
             }
             void QScatterSeries::setMarkerShape(MarkerShape shape)
             {
                 Q_D(QScatterSeries);
                 if (d->m_shape != shape) {
                     d->m_shape = shape;
                     emit d->updated();
                 }
             }
             qreal QScatterSeries::markerSize() const
             {
                 Q_D(const QScatterSeries);
                 return d->m_size;
             }
             void QScatterSeries::setMarkerSize(qreal size)
             {
                 Q_D(QScatterSeries);
                 if (!qFuzzyIsNull(d->m_size - size)) {
                     d->m_size = size;
                     emit d->updated();
                 }
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QScatterSeriesPrivate::QScatterSeriesPrivate(QScatterSeries* q):QXYSeriesPrivate(q),
                m_shape(QScatterSeries::MarkerShapeCircle),
                m_size(15.0)
             {
             };
             Chart* QScatterSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QScatterSeries);
                 ScatterChartItem *scatter = new ScatterChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     scatter->setAnimator(presenter->animator());
                     scatter->setAnimation(new XYAnimation(scatter));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return scatter;
             }
             #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.cpp +12 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qsplineseries.h"
             #include "qsplineseries_p.h"
             #include "splinechartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_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
             */
             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.
               */
             QSplineSeries::QSplineSeries(QObject *parent) :
                 QLineSeries(*new QSplineSeriesPrivate(this),parent)
             {
                 Q_D(QSplineSeries);
                 QObject::connect(this,SIGNAL(pointAdded(int)), d, SLOT(updateControlPoints()));
                 QObject::connect(this,SIGNAL(pointRemoved(int)), d, SLOT(updateControlPoints()));
                 QObject::connect(this,SIGNAL(pointReplaced(int)), d, SLOT(updateControlPoints()));
             }
             /*!
               Destroys the object.
             */
             QSplineSeries::~QSplineSeries()
             {
                 Q_D(QSplineSeries);
                 if(d->m_dataset){
                     d->m_dataset->removeSeries(this);
                 }
             }
             QAbstractSeries::SeriesType QSplineSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeSpline;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QSplineSeriesPrivate::QSplineSeriesPrivate(QSplineSeries* q):QLineSeriesPrivate(q)
             {
             }
             /*!
               Calculates control points which are needed by QPainterPath.cubicTo function to draw the cubic Bezier cureve between two points.
               */
             void QSplineSeriesPrivate::calculateControlPoints()
             {
                 Q_Q(QSplineSeries);
                 const QList<QPointF>& points = q->points();
                 int n = points.count() - 1;
                 if (n == 1)
                 {
                     //for n==1
                     m_controlPoints[0].setX((2 * points[0].x() + points[1].x()) / 3);
                     m_controlPoints[0].setY((2 * points[0].y() + points[1].y()) / 3);
                     m_controlPoints[1].setX(2 * m_controlPoints[0].x() - points[0].x());
                     m_controlPoints[1].setY(2 * m_controlPoints[0].y() - points[0].y());
                     return;
                 }
                 // Calculate first Bezier control points
                 // Set of equations for P0 to Pn points.
                 //
                 //  |   2   1   0   0   ... 0   0   0   ... 0   0   0   |   |   P1_1    |   |   P0 + 2 * P1             |
                 //  |   1   4   1   0   ... 0   0   0   ... 0   0   0   |   |   P1_2    |   |   4 * P1 + 2 * P2         |
                 //  |   0   1   4   1   ... 0   0   0   ... 0   0   0   |   |   P1_3    |   |   4 * P2 + 2 * P3         |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   ... 1   4   1   ... 0   0   0   | * |   P1_i    | = |   4 * P(i-1) + 2 * Pi     |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   0   0   0   0   ... 1   4   1   |   |   P1_(n-1)|   |   4 * P(n-2) + 2 * P(n-1) |
                 //  |   0   0   0   0   0   0   0   0   ... 0   2   7   |   |   P1_n    |   |   8 * P(n-1) + Pn         |
                 //
                 QVector<qreal> vector;
                 vector.resize(n);
                 vector[0] = points[0].x() + 2 * points[1].x();
                 for (int i = 1; i < n - 1; ++i){
                     vector[i] = 4 * points[i].x() + 2 * points[i + 1].x();
                 }
                 vector[n - 1] = (8 * points[n-1].x() + points[n].x()) / 2.0;
                 QVector<qreal> xControl = firstControlPoints(vector);
                 vector[0] = points[0].y() + 2 * points[1].y();
                 for (int i = 1; i < n - 1; ++i) {
                     vector[i] = 4 * points[i].y() + 2 * points[i + 1].y();
                 }
                 vector[n - 1] = (8 * points[n-1].y() + points[n].y()) / 2.0;
                 QVector<qreal> yControl = firstControlPoints(vector);
                 for (int i = 0,j =0; i < n; ++i, ++j) {
                     m_controlPoints[j].setX(xControl[i]);
                     m_controlPoints[j].setY(yControl[i]);
                     j++;
                     if (i < n - 1){
                         m_controlPoints[j].setX(2 * points[i+1].x() - xControl[i + 1]);
                         m_controlPoints[j].setY(2 * points[i+1].y() - yControl[i + 1]);
                     }else{
                         m_controlPoints[j].setX((points[n].x() + xControl[n - 1]) / 2);
                         m_controlPoints[j].setY((points[n].y() + yControl[n - 1]) / 2);
                     }
                 }
             }
             QVector<qreal> QSplineSeriesPrivate::firstControlPoints(const QVector<qreal>& vector)
             {
                 QVector<qreal> result;
                 int count = vector.count();
                 result.resize(count);
                 result[0] = vector[0] / 2.0;
                 QVector<qreal> temp;
                 temp.resize(count);
                 temp[0] = 0;
                 qreal b = 2.0;
                 for (int i = 1; i < count; i++) {
                     temp[i] = 1 / b;
                     b = (i < count - 1 ? 4.0 : 3.5) - temp[i];
                     result[i]=(vector[i] - result[i - 1]) / b;
                 }
                 for (int i = 1; i < count; i++)
                     result[count - i - 1] -= temp[count - i] * result[count - i];
                 return result;
             }
             QPointF QSplineSeriesPrivate::controlPoint(int index) const
             {
                 //    Q_D(const QSplineSeries);
                 //    return d->m_controlPoints[index];
                 return m_controlPoints[index];
             }
             /*!
               Updates the control points, besed on currently avaiable knots.
               */
             void QSplineSeriesPrivate::updateControlPoints()
             {
                 Q_Q(QSplineSeries);
                 if (q->count() > 1) {
                     m_controlPoints.resize(2*q->count()-2);
                     calculateControlPoints();
                 }
             }
             Chart* QSplineSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QSplineSeries);
                 SplineChartItem* spline  = new SplineChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     spline->setAnimator(presenter->animator());
                     spline->setAnimation(new SplineAnimation(spline));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return spline;
             }
             #include "moc_qsplineseries.cpp"
             #include "moc_qsplineseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.cpp +52 -6

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
+            /*!
+                \qmlclass XYSeries
+                \brief The XYSeries class is a base class for line, spline and scatter series.
+                The class cannot be instantiated directly.
+            */
             /*!
                 \property QXYSeries::pointsVisible
+                Controls if the data points are visible and should be drawn.
+            */
+            /*!
+                \qmlproperty bool XYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \property QXYSeries::color
-                Line (pen) color of the series. This is a convenience property for modifying the color of pen.
+                The color of the series. This is line (pen) color in case of QLineSeries or QSplineSeries and
-                \sa QXYSeries::pen()
+                fill (brush) color in case of QScatterSeries or QAreaSeries.
+                \sa QXYSeries::pen(), QXYSeries::brush()
+            */
+            /*!
+                \qmlproperty color XYSeries::color
+                The color of the series. This is line (pen) color in case of LineSeries or SplineSeries and
+                fill (brush) color in case of ScatterSeries or AreaSeries.
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart.
             */
+            /*!
+                \qmlsignal XYSeries::onClicked(QPointF point)
+                Signal is emitted when user clicks the \a point on chart. For example:
+                \code
+                LineSeries {
+                    XyPoint { x: 0; y: 0 }
+                    XyPoint { x: 1.1; y: 2.1 }
+                    onClicked: console.log("onClicked: " + point.x + ", " + point.y);
+                }
+                \endcode
+            */
             /*!
                 \fn void QXYSeries::pointReplaced(int index)
-                \brief Signal is emitted when user replaces a point at \a index.
+                Signal is emitted when a point has been replaced at \a index.
                 \sa replace()
             */
+            /*!
+                \qmlsignal XYSeries::pointReplaced(int index)
+                Signal is emitted when a point has been replaced at \a index.
+            */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
-                \brief Signal is emitted when user adds a point at \a index.
+                Signal is emitted when a point has been added at \a index.
                 \sa append(), insert()
             */
+            /*!
+                \qmlsignal XYSeries::pointAdded(int index)
+                Signal is emitted when a point has been added at \a index.
+            */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
-                \brief Signal is emitted when user removes a point at \a index.
+                Signal is emitted when a point has been removed from \a index.
                 \sa remove()
             */
+            /*!
+                \qmlsignal XYSeries::pointRemoved(int index)
+                Signal is emitted when a point has been removed from \a index.
+            */
             /*!
                 \fn void QXYSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
+            /*!
+                \qmlsignal XYSeries::colorChanged(QColor color)
+                Signal is emitted when the line (pen) color has changed to \a color.
+            */
             /*!
                 \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
+                \qmlmethod XyPoint XYSeries::at(int index)
+            */
+            /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QXYSeries::QXYSeries(QXYSeriesPrivate &d,QObject *parent) : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(qreal x,qreal y)
             {
                 append(QPointF(x,y));
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 d->m_points<<point;
             //    emit d->pointAdded(d->m_points.count()-1);
                 emit pointAdded(d->m_points.count()-1);
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QList<QPointF> &points)
             {
                 foreach(const QPointF& point , points) {
                     append(point);
                 }
             }
             /*!
               Replaces data point \a oldX \a oldY with data point \a newX \a newY.
             */
             void QXYSeries::replace(qreal oldX,qreal oldY,qreal newX,qreal newY)
             {
                 replace(QPointF(oldX,oldY),QPointF(newX,newY));
             }
             /*!
               Replaces \a oldPoint with \a newPoint.
             */
             void QXYSeries::replace(const QPointF &oldPoint,const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(oldPoint);
                 if(index==-1) return;
                 d->m_points[index] = newPoint;
             //    emit d->pointReplaced(index);
                 emit pointReplaced(index);
             }
             /*!
               Removes current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x,qreal y)
             {
                 remove(QPointF(x,y));
             }
             /*!
               Removes current \a point x value.
               Note: point y value is ignored.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if(index==-1) return;
                 d->m_points.remove(index);
             //    emit d->pointRemoved(index);
                 emit pointRemoved(index);
             }
             /*!
                Inserts a \a point in the series at \a index position.
             */
             void QXYSeries::insert(int index, const QPointF &point)
             {
                 Q_D(QXYSeries);
                 d->m_points.insert(index, point);
             //    emit d->pointAdded(index);
                 emit pointAdded(index);
             }
             /*!
                 Removes all points from the series.
             */
             void QXYSeries::clear()
             {
                 Q_D(QXYSeries);
                 for (int i = d->m_points.size() - 1; i >= 0; i--)
                     remove(d->m_points.at(i));
             }
             /*!
                 \internal \a pos
             */
             QList<QPointF> QXYSeries::points() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.toList();
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.count();
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen!=pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen QXYSeries::pen() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QXYSeries);
                 if (d->m_brush!=brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QXYSeries::brush() const
             {
                 Q_D(const QXYSeries);
                 return d->m_brush;
             }
             void QXYSeries::setColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit colorChanged(color);
                 }
             }
             QColor QXYSeries::color() const
             {
                 return pen().color();
             }
             void QXYSeries::setPointsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointsVisible != visible){
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             bool QXYSeries::pointsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointsVisible;
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QPointF &point)
             {
                 append(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QList<QPointF>& points)
             {
                 append(points);
                 return *this;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_pointsVisible(false)
             {
             }
             void QXYSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 Q_Q(QXYSeries);
                 const QList<QPointF>& points = q->points();
                 if(points.isEmpty()){
                     minX=0.0;
                     minY=0.0;
                     maxX=1.0;
                     maxY=1.0;
                 }
                 for (int i = 0; i < points.count(); i++)
                 {
                     qreal x = points[i].x();
                     qreal y = points[i].y();
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             QList<LegendMarker*> QXYSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<LegendMarker*> list;
                 return list << new XYLegendMarker(q,legend);
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/qmlchartproperties/qml/qmlchartproperties/AreaChart.qml +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             ChartView {
                 title: "area series"
                 anchors.fill: parent
                 axisXLabels: ["0", "2000", "1", "2001", "2", "2002", "3", "2003", "4", "2004", "5", "2005",
                     "6", "2006", "7", "2007", "8", "2008", "9", "2009", "10", "2010", "11", "2011"]
                 property variant series: daSeries
                 AreaSeries {
                     id: daSeries
                     name: "area 1"
+                    onSelected: console.log("areaSeries.onSelected");
+                    onClicked: console.log("areaSeries.onClicked: " + point.x + ", " + point.y);
                     upperSeries: LineSeries {
                         XyPoint { x: 0; y: 1 }
                         XyPoint { x: 1; y: 1 }
                         XyPoint { x: 2; y: 3 }
                         XyPoint { x: 3; y: 3 }
                         XyPoint { x: 4; y: 2 }
                         XyPoint { x: 5; y: 0 }
                         XyPoint { x: 6; y: 2 }
                         XyPoint { x: 7; y: 1 }
                         XyPoint { x: 8; y: 2 }
                         XyPoint { x: 9; y: 1 }
                         XyPoint { x: 10; y: 3 }
                         XyPoint { x: 11; y: 3 }
                     }
                     lowerSeries: LineSeries {
                         XyPoint { x: 0; y: 0 }
                         XyPoint { x: 1; y: 0 }
                         XyPoint { x: 2; y: 0 }
                         XyPoint { x: 3; y: 0 }
                         XyPoint { x: 4; y: 0 }
                         XyPoint { x: 5; y: 0 }
                         XyPoint { x: 6; y: 0 }
                         XyPoint { x: 7; y: 0 }
                         XyPoint { x: 8; y: 0 }
                         XyPoint { x: 9; y: 0 }
                         XyPoint { x: 10; y: 0 }
                         XyPoint { x: 11; y: 0 }
                     }
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/BarChart.qml +4 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             ChartView {
                 title: "Bar series"
                 anchors.fill: parent
                 theme: ChartView.ChartThemeLight
                 legend.alignment: Qt.AlignBottom
                 axisXLabels: ["0", "2007", "1", "2008", "2", "2009", "3", "2010", "4", "2011", "5", "2012"]
                 property variant series: daSeries
                 BarSeries {
                     id: daSeries
                     name: "bar"
                     onClicked: console.log("onClicked: " + barset + " " + index);
                     onHovered: console.log("onHovered: " + barset + " " + status);
-                    BarSet { label: "Bob"; values: [4, 7, 3, 10, 5, 6] }
+                    BarSet { label: "Bob"; values: [4, 7, 3, 10, 5, 6]
+                        onClicked: console.log("barset.onClicked: " + index);
+                        onHovered: console.log("barset.onHovered: " + status);
+                    }
                     BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 8] }
                     BarSet { label: "James"; values: [3, 5, 8, 5, 4, 7] }
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/LineChart.qml +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             ChartView {
                 title: "line series"
                 anchors.fill: parent
                 property variant series: daSeries
                 LineSeries {
                     id: daSeries
                     name: "line 1"
+                    onClicked: console.log("onClicked: " + point.x + ", " + point.y);
                     XyPoint { x: 0; y: 0 }
                     XyPoint { x: 1.1; y: 2.1 }
                     XyPoint { x: 1.9; y: 3.3 }
                     XyPoint { x: 2.1; y: 2.1 }
                     XyPoint { x: 2.9; y: 4.9 }
                     XyPoint { x: 3.4; y: 3.0 }
                     XyPoint { x: 4.1; y: 3.3 }
                 }
                 LineSeries {
                     name: "line 2"
                     XyPoint { x: 1.1; y: 1.1 }
                     XyPoint { x: 1.9; y: 2.3 }
                     XyPoint { x: 2.1; y: 1.1 }
                     XyPoint { x: 2.9; y: 3.9 }
                     XyPoint { x: 3.4; y: 2.0 }
                     XyPoint { x: 4.1; y: 2.3 }
                 }
             }

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