HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2727:d7bc4e870cdd

Add missing QML types to the documentation...

Titta Heikkala -

r2727:d7bc4e870cdd

parent child

Context file:

r2727:d7bc4e870cdd

Collapse all files

src/charts/doc/qtcharts.qdocconf +6 -2

             include($QT_INSTALL_DOCS/global/macros.qdocconf)
             include($QT_INSTALL_DOCS/global/qt-cpp-defines.qdocconf)
             include($QT_INSTALL_DOCS/global/compat.qdocconf)
             include($QT_INSTALL_DOCS/global/fileextensions.qdocconf)
             include($QT_INSTALL_DOCS/global/qt-html-templates-offline.qdocconf)
             project = Qt Charts
             description = Qt Charts Reference Documentation
             version = 2.0.0
-            sourcedirs += ..
+            sourcedirs += .. \
-            headerdirs += ..
+                          ../../chartsqml2
+            headerdirs += .. \
+                          ../../chartsqml2
             exampledirs += ../../../examples/charts \
                            snippets
             imagedirs += images
             examplesinstallpath = charts
+            sources.fileextensions  = "*.cpp *.qdoc"
             indexes +=  $QT_INSTALL_DOCS/qtcore/qtcore.index \
                         $QT_INSTALL_DOCS/qtgui/qtgui.index \
                         $QT_INSTALL_DOCS/qtqml/qtqml.index \
                         $QT_INSTALL_DOCS/qtquick/qtquick.index \
                         $QT_INSTALL_DOCS/qtmultimedia/qtmultimedia.index
             Cpp.ignoretokens        = Q_INVOKABLE \
                                       QT_CHARTS_EXPORT \
                                       QT_CHARTS_END_NAMESPACE \
                                       QT_CHARTS_BEGIN_NAMESPACE
             qhp.projects                  = QtCharts
             qhp.QtCharts.file             = qtcharts.qhp
             qhp.QtCharts.namespace        = com.digia.qtcharts.200
             qhp.QtCharts.virtualFolder    = qtcharts
             qhp.QtCharts.indexTitle       = Qt Charts Reference
             qhp.QtCharts.indexRoot        =
             qhp.QtCharts.filterAttributes                  = qtcharts 2.0.0 qtrefdoc
             qhp.QtCharts.customFilters.Qt.name             = QtCharts 2.0.0
             qhp.QtCharts.customFilters.Qt.filterAttributes = qtcharts 2.0.0
             qhp.QtCharts.subprojects = gettingstarted classes types examples
             qhp.QtCharts.subprojects.gettingstarted.title      = Getting Started
             qhp.QtCharts.subprojects.gettingstarted.indexTitle = Qt Charts Getting Started
             qhp.QtCharts.subprojects.gettingstarted.selectors  = fake:page
             qhp.QtCharts.subprojects.gettingstarted.sortPages  = true
             qhp.QtCharts.subprojects.classes.title      = C++ Classes
             qhp.QtCharts.subprojects.classes.indexTitle = Qt Charts C++ Classes
             qhp.QtCharts.subprojects.classes.selectors  = class
             qhp.QtCharts.subprojects.classes.sortPages  = true
             qhp.QtCharts.subprojects.types.title      = QML Types
             qhp.QtCharts.subprojects.types.indexTitle = Qt Charts QML Types
             qhp.QtCharts.subprojects.types.selectors  = qmlclass
             qhp.QtCharts.subprojects.types.sortPages  = true
             qhp.QtCharts.subprojects.examples.title      = Examples
             qhp.QtCharts.subprojects.examples.indexTitle = Qt Charts Examples
             qhp.QtCharts.subprojects.examples.selectors  = fake:example
             qhp.QtCharts.subprojects.examples.sortPages  = true
             navigation.landingpage = Qt Charts
             navigation.cppclassespage = Qt Charts C++ Classes
             navigation.qmltypespage = Qt Charts QML Types
             buildversion = Qt Charts $QT_VERSION Reference Documentation

src/chartsqml2/declarativeboxplotseries.cpp +4 0

             /****************************************************************************
             **
             ** Copyright (C) 2014 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 "declarativebarseries.h"
             #include "declarativeboxplotseries.h"
             #include <QtCharts/QBoxSet>
             #include <QtCharts/QVBoxPlotModelMapper>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \qmltype BoxSet
                 \instantiates QBoxSet
                 \inqmlmodule QtCharts
+                \brief Building block for box-and-whiskers chart.
                 BoxSet represents one box-and-whiskers item. It takes five values to create a graphical
                 representation of range and three medians. There are two ways to give the values. The first one
                 is with constructor or with append method. In these the values have to be given in the following
                 order: lower extreme, lower quartile, median, upper quartile and upper extreme. The second
                 method is to create an empty QBoxSet instance and give the values using value specific methods.
                 \sa BoxPlotSeries
             */
             /*!
                 \qmlproperty string BoxSet::values
                 The values on the box-and-whiskers set.
             */
             /*!
                 \qmlproperty string BoxSet::label
                 Defines the label of the box-and-whiskers set.
             */
             /*!
                 \qmlproperty int BoxSet::count
                 The count of values on the box-and-whiskers set
             */
             /*!
                 \qmlmethod void BoxSet::at(int index)
                 Returns the value at \a index position.
             */
             /*!
                 \qmlmethod void BoxSet::append(qreal value)
                 Appends new value \a value to the end of set.
             */
             /*!
                 \qmlmethod void BoxSet::clear()
                 Sets all values on the set to 0.
             */
             /*!
                 \qmlmethod void BoxSet::setValue(int index, qreal value)
                 Sets a new \a value on the \a index position.
             */
             /*!
                 \qmlsignal BoxSet::onClicked()
                 This signal is emitted when the user clicks with a mouse on top of box-and-whiskers item.
             */
             /*!
                 \qmlsignal BoxSet::onHovered(bool status)
                 The signal is emitted if mouse is hovered on top of box-and-whiskers item.
                 Parameter \a status is true, if mouse entered on top of the item, and false if mouse left from top of the item.
             */
             /*!
                 \qmlsignal BoxSet::onPenChanged()
                 This signal is emitted when the pen of the box-and-whiskers item has changed.
             */
             /*!
                 \qmlsignal BoxSet::onBrushChanged()
                 This signal is emitted when the brush of the box-and-whiskers item has changed.
             */
             /*!
                 \qmlsignal BoxSet::onChangedValues()
                 This signal is emitted when multiple values have been changed on the box-and-whiskers item.
             */
             /*!
                 \qmlsignal BoxSet::onChangedValue(int index)
                 This signal is emitted values the value in the box-and-whiskers item has been modified.
                 Parameter \a index indicates the position of the modified value.
             */
             /*!
                 \qmlsignal BoxSet::onCleared()
                 This signal is emitted when all the values on the set are cleared to 0.
             */
             /*!
                 \qmltype BoxPlotSeries
                 \instantiates QBoxPlotSeries
                 \inqmlmodule QtCharts
                 \inherits AbstractSeries
+                \brief Series for creating box-and-whiskers chart.
                 BoxPlotSeries represents a series of data shown as box-and-whiskers bars. The purpose of this
                 class is to act as a container for single box-and-whiskers items. Each item is drawn to own
                 slot. If chart includes multiple instances of BoxPlotSeries then box-and-whiskers items with the
                 same index are drawn to same slot.
                 The following QML shows how to create a simple box-and-whiskers chart:
                 \code
                 import QtQuick 2.0
                 import QtCharts 2.0
                 ChartView {
                     title: "Box Plot series"
                     width: 400
                     height: 300
                     theme: ChartView.ChartThemeBrownSand
                     legend.alignment: Qt.AlignBottom
                     BoxPlotSeries {
                         id: plotSeries
                         name: "Income"
                         BoxSet { label: "Jan"; values: [3, 4, 5.1, 6.2, 8.5] }
                         BoxSet { label: "Feb"; values: [5, 6, 7.5, 8.6, 11.8] }
                         BoxSet { label: "Mar"; values: [3.2, 5, 5.7, 8, 9.2] }
                         BoxSet { label: "Apr"; values: [3.8, 5, 6.4, 7, 8] }
                         BoxSet { label: "May"; values: [4, 5, 5.2, 6, 7] }
                     }
                 }
                 \endcode
                 \beginfloatleft
                 \image examples_qmlboxplot.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \qmlmethod BoxPlotSeries::append(string label, VariantList values)
                 Appends a new box-and-whiskers set with \a label and \a values to the series.
              */
             /*!
                 \qmlmethod BoxPlotSeries::append(BoxSet box)
                 Appends the \a box to the series.
             */
             /*!
                 \qmlmethod BoxPlotSeries::insert(int index, string label, VariantList values)
                 Inserts a new box-and-whiskers set with \a label and \a values at the \a index position.
             */
             /*!
                 \qmlmethod BoxPlotSeries::remove(QBoxSet boxset)
                 Removes the \a boxset from the series.
             */
             /*!
                 \qmlmethod BoxPlotSeries::clear()
                 Removes all boxsets from the series. Deletes removed sets.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onClicked(BoxSet boxset);
                 Signal is emitted when the user clicks the \a boxset on the chart.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onHovered(bool status, BoxSet boxset);
                 Signal is emitted when there is change in hover \a status over \a boxset.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onCountChanged();
                 Signal is emitted when there is change in count of box-and-whiskers items in the series.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onBoxsetsAdded()
                 Signal is emitted when new box-and-whiskers sets are added to the series.
              */
             /*!
                 \qmlsignal BoxPlotSeries::onBoxsetsRemoved()
                 Signal is emitted when new box-and-whiskers sets are removed from the series.
              */
             /*!
                 \qmlproperty AbstractAxis BoxPlotSeries::axisX
                 The x axis used for the series. If you leave both axisX and axisXTop undefined, a BarCategoriesAxis is created for
                 the series.
                 \sa axisXTop
             */
             /*!
                 \qmlproperty AbstractAxis BoxPlotSeries::axisY
                 The y axis used for the series. If you leave both axisY and axisYRight undefined, a ValueAxis is created for
                 the series.
                 \sa axisYRight
             */
             /*!
                 \qmlproperty AbstractAxis BoxPlotSeries::axisXTop
                 The x axis used for the series, drawn on top of the chart view. Note that you can only provide either axisX or
                 axisXTop, but not both.
                 \sa axisX
             */
             /*!
                 \qmlproperty AbstractAxis BoxPlotSeries::axisYRight
                 The y axis used for the series, drawn to the right on the chart view. Note that you can only provide either axisY
                 or axisYRight, but not both.
                 \sa axisY
             */
             /*!
                 \qmlproperty bool BoxPlotSeries::boxOutlineVisible
                 This property configures the visibility of the middle box outline.
             */
             /*!
                 \qmlproperty qreal BoxPlotSeries::boxWidth
                 This property configures the width of the box-and-whiskers item. The value signifies the relative
                 width of the box-and-whiskers item inside its own slot. The value can between 0.0 and 1.0. Negative values
                 are clamped to 0.0 and values over 1.0 are clamped to 1.0.
             */
             /*!
                 \qmlproperty Pen BoxPlotSeries::pen
                 This property configures the pen of the box-and-whiskers items.
             */
             /*!
                 \qmlproperty Brush BoxPlotSeries::brush
                 This property configures the brush of the box-and-whiskers items.
             */
             /*!
                 \qmlproperty int BoxPlotSeries::count
                 The count of sets in series.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onBoxOutlineVisibilityChanged()
                 Signal is emitted when the middle box outline visibility is changed.
              */
             /*!
                 \qmlsignal BoxPlotSeries::onBoxWidthChanged()
                 Signal is emitted when the width of the box-and-whiskers item is changed.
              */
             /*!
                 \qmlsignal BoxPlotSeries::onPenChanged()
                 Signal is emitted when the pen for box-and-whiskers items has changed.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onBrushChanged()
                 Signal is emitted when the brush for box-and-whiskers items has changed.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onClicked(BoxSet boxset)
                 Signal is emitted when the user clicks the \a boxset on the chart.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onHovered(bool status, BoxSet boxset)
                 Signal is emitted when there is change in hover \a status over \a boxset.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onAxisXChanged(AbstractAxis axis)
                 Signal is emitted when there is change in X axis.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onAxisYChanged(AbstractAxis axis)
                 Signal is emitted when there is change in Y axis.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onAxisXTopChanged(AbstractAxis axis)
                 Signal is emitted when there is change in top X axis.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onAxisYRightChanged(AbstractAxis axis)
                 Signal is emitted when there is change in Y right axis.
             */
             DeclarativeBoxSet::DeclarativeBoxSet(const QString label, QObject *parent)
                 : QBoxSet(label, parent)
             {
                 connect(this, SIGNAL(valuesChanged()), this, SIGNAL(changedValues()));
                 connect(this, SIGNAL(valueChanged(int)), this, SIGNAL(changedValue(int)));
                 connect(this, SIGNAL(brushChanged()), this, SLOT(handleBrushChanged()));
             }
             QVariantList DeclarativeBoxSet::values()
             {
                 QVariantList values;
                 for (int i(0); i < 5; i++)
                     values.append(QVariant(QBoxSet::at(i)));
                 return values;
             }
             void DeclarativeBoxSet::setValues(QVariantList values)
             {
                 for (int i(0); i < values.count(); i++) {
                     if (values.at(i).canConvert(QVariant::Double))
                         QBoxSet::append(values[i].toDouble());
                 }
             }
             QString DeclarativeBoxSet::brushFilename() const
             {
                 return m_brushFilename;
             }
             void DeclarativeBoxSet::setBrushFilename(const QString &brushFilename)
             {
                 QImage brushImage(brushFilename);
                 if (QBoxSet::brush().textureImage() != brushImage) {
                     QBrush brush = QBoxSet::brush();
                     brush.setTextureImage(brushImage);
                     QBoxSet::setBrush(brush);
                     m_brushFilename = brushFilename;
                     m_brushImage = brushImage;
                     emit brushFilenameChanged(brushFilename);
                 }
             }
             void DeclarativeBoxSet::handleBrushChanged()
             {
                 // If the texture image of the brush has changed along the brush
                 // the brush file name needs to be cleared.
                 if (!m_brushFilename.isEmpty() && QBoxSet::brush().textureImage() != m_brushImage) {
                     m_brushFilename.clear();
                     emit brushFilenameChanged(QString(""));
                 }
             }
             // =====================================================
             DeclarativeBoxPlotSeries::DeclarativeBoxPlotSeries(QQuickItem *parent) :
                 QBoxPlotSeries(parent),
                 m_axes(new DeclarativeAxes(this))
             {
                 connect(m_axes, SIGNAL(axisXChanged(QAbstractAxis*)), this, SIGNAL(axisXChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisYChanged(QAbstractAxis*)), this, SIGNAL(axisYChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SIGNAL(axisXTopChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SIGNAL(axisYRightChanged(QAbstractAxis*)));
                 connect(this, SIGNAL(hovered(bool, QBoxSet*)), this, SLOT(onHovered(bool, QBoxSet*)));
                 connect(this, SIGNAL(clicked(QBoxSet*)), this, SLOT(onClicked(QBoxSet*)));
                 connect(this, SIGNAL(brushChanged()), this, SLOT(handleBrushChanged()));
             }
             void DeclarativeBoxPlotSeries::classBegin()
             {
             }
             void DeclarativeBoxPlotSeries::componentComplete()
             {
                 foreach (QObject *child, children()) {
                     if (qobject_cast<DeclarativeBoxSet *>(child)) {
                         QBoxPlotSeries::append(qobject_cast<DeclarativeBoxSet *>(child));
                     } else if (qobject_cast<QVBoxPlotModelMapper *>(child)) {
                         QVBoxPlotModelMapper *mapper = qobject_cast<QVBoxPlotModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             QQmlListProperty<QObject> DeclarativeBoxPlotSeries::seriesChildren()
             {
                 return QQmlListProperty<QObject>(this, 0, &DeclarativeBoxPlotSeries::appendSeriesChildren ,0,0,0);
             }
             void DeclarativeBoxPlotSeries::appendSeriesChildren(QQmlListProperty<QObject> *list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBoxSet *DeclarativeBoxPlotSeries::at(int index)
             {
                 QList<QBoxSet *> setList = boxSets();
                 if (index >= 0 && index < setList.count())
                     return qobject_cast<DeclarativeBoxSet *>(setList[index]);
                 return 0;
             }
             DeclarativeBoxSet *DeclarativeBoxPlotSeries::insert(int index, const QString label, QVariantList values)
             {
                 DeclarativeBoxSet *barset = new DeclarativeBoxSet(label, this);
                 barset->setValues(values);
                 if (QBoxPlotSeries::insert(index, barset))
                     return barset;
                 delete barset;
                 return 0;
             }
             void DeclarativeBoxPlotSeries::onHovered(bool status, QBoxSet *boxset)
             {
                 emit hovered(status, qobject_cast<DeclarativeBoxSet *>(boxset));
             }
             void DeclarativeBoxPlotSeries::onClicked(QBoxSet *boxset)
             {
                 emit clicked(qobject_cast<DeclarativeBoxSet *>(boxset));
             }
             QString DeclarativeBoxPlotSeries::brushFilename() const
             {
                 return m_brushFilename;
             }
             void DeclarativeBoxPlotSeries::setBrushFilename(const QString &brushFilename)
             {
                 QImage brushImage(brushFilename);
                 if (QBoxPlotSeries::brush().textureImage() != brushImage) {
                     QBrush brush = QBoxPlotSeries::brush();
                     brush.setTextureImage(brushImage);
                     QBoxPlotSeries::setBrush(brush);
                     m_brushFilename = brushFilename;
                     m_brushImage = brushImage;
                     emit brushFilenameChanged(brushFilename);
                 }
             }
             void DeclarativeBoxPlotSeries::handleBrushChanged()
             {
                 // If the texture image of the brush has changed along the brush
                 // the brush file name needs to be cleared.
                 if (!m_brushFilename.isEmpty() && QBoxPlotSeries::brush().textureImage() != m_brushImage) {
                     m_brushFilename.clear();
                     emit brushFilenameChanged(QString(""));
                 }
             }
             #include "moc_declarativeboxplotseries.cpp"
             QT_CHARTS_END_NAMESPACE

src/chartsqml2/declarativechart.cpp +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2014 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 <QtGui/QPainter>
             #include "declarativelineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeboxplotseries.h"
             #include "declarativescatterseries.h"
             #include <QtCharts/QBarCategoryAxis>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QLogValueAxis>
             #include <QtCharts/QCategoryAxis>
             #include <private/qabstractseries_p.h>
             #include "declarativemargins.h"
             #include <private/chartdataset_p.h>
             #include "declarativeaxes.h"
             #include <private/qchart_p.h>
             #include <QtCharts/QPolarChart>
             #ifndef QT_ON_ARM
                 #include <QtCharts/QDateTimeAxis>
             #endif
             #include <QtWidgets/QGraphicsSceneMouseEvent>
             #include <QtWidgets/QGraphicsSceneHoverEvent>
             #include <QtWidgets/QApplication>
             #include <QtCore/QTimer>
             #include <QtCore/QThread>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \qmltype ChartView
                 \instantiates DeclarativeChart
                 \inqmlmodule QtCharts
+                \brief Chart element.
                 ChartView element is the parent that is responsible for showing different chart series types.
                 The following QML shows how to create a simple chart with one pie series:
                 \snippet qmlpiechart/qml/qmlpiechart/main.qml 1
                 \snippet qmlpiechart/qml/qmlpiechart/main.qml 2
                 \snippet qmlpiechart/qml/qmlpiechart/main.qml 3
                 \beginfloatleft
                 \image examples_qmlpiechart.png
                 \endfloat
                 \clearfloat
             */
             /*!
               \qmlproperty Theme ChartView::theme
               Theme defines the visual appearance of the chart, including for example colors, fonts, line
               widths and chart background.
             */
             /*!
               \qmlproperty Animation ChartView::animationOptions
               Animation configuration of the chart. One of ChartView.NoAnimation, ChartView.GridAxisAnimations,
               ChartView.SeriesAnimations or ChartView.AllAnimations.
             */
             /*!
               \qmlproperty Font ChartView::titleFont
               The title font of the chart.
               See the Qt documentation for more details of Font.
             */
             /*!
               \qmlproperty string ChartView::title
               The title of the chart, shown on top of the chart.
               \sa ChartView::titleColor
             */
             /*!
               \qmlproperty color ChartView::titleColor
               The color of the title text.
             */
             /*!
               \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 real ChartView::backgroundRoundness
               The diameter of the rounding cirle at the corners of the chart background.
             */
             /*!
               \qmlproperty color ChartView::plotAreaColor
               The color of the background of the chart's plot area. By default plot area background uses chart's
               background color.
               \sa ChartView::backgroundColor
             */
             /*!
               \qmlproperty bool ChartView::dropShadowEnabled
               The chart's border drop shadow. Set to true to enable drop shadow.
             */
             /*!
               \qmlproperty real ChartView::topMargin
               Deprecated; use margins instead.
             */
             /*!
               \qmlproperty real ChartView::bottomMargin
               Deprecated; use margins instead.
             */
             /*!
               \qmlproperty real ChartView::leftMargin
               Deprecated; use margins instead.
             */
             /*!
               \qmlproperty real ChartView::rightMargin
               Deprecated; use margins instead.
             */
             /*!
               \qmlproperty Margins ChartView::minimumMargins
               Deprecated; use margins instead.
               The minimum margins allowed between the outer bounds and the plotArea of the ChartView. Margins
               area of ChartView is used for drawing title, axes and legend. Please note that setting the
               properties of minimumMargins may be bigger than the defined value, depending on other ChartView
               properties that affect it's layout. If you need to know the actual plotting area used at any
               given time, you can check ChartView::plotArea instead.
             */
             /*!
               \qmlproperty rect ChartView::plotArea
               The area on the ChartView that is used for drawing series. This is the ChartView rect without the
               margins.
               \sa ChartView::minimumMargins
             */
             /*!
               \qmlproperty Margins ChartView::margins
               The minimum margins allowed between the outer bounds and the plotArea of the ChartView. Margins
               area of ChartView is used for drawing title, axes and legend.
             */
             /*!
               \qmlproperty bool ChartView::localizeNumbers
               \since QtCharts 2.0
               When \c{true}, all generated numbers appearing in various series and axis labels will be
               localized using the default QLocale of the application, which defaults to the system locale.
               When \c{false}, the "C" locale is always used.
               Defaults to \c{false}.
               \sa locale
             */
             /*!
               \qmlproperty locale ChartView::locale
               \since QtCharts 2.0
               Sets the locale used to format various chart labels when localizeNumbers is \c{true}.
               This also determines the locale used to format DateTimeAxis labels regardless of
               localizeNumbers property.
               Defaults to application default locale at the time the chart is constructed.
               \sa localizeNumbers
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(int index)
               Returns the series with \a index on the chart. This allows you to loop through the series of a chart together with
               the count property of the chart.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(string name)
               Returns the first series on the chart with \a name. If there is no series with that name, returns null.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::createSeries(SeriesType type, string name, AbstractAxis axisX, AbstractAxis axisY)
               Creates a series object of \a type to the chart with name \a name, optional axis \a axisX and
               optional axis \a axisY. For example:
               \code
                 // lineSeries is a LineSeries object that has already been added to the ChartView; re-use it's axes
                 var myAxisX = chartView.axisX(lineSeries);
                 var myAxisY = chartView.axisY(lineSeries);
                 var scatter = chartView.createSeries(ChartView.SeriesTypeScatter, "scatter series", myAxisX, myAxisY);
               \endcode
             */
             /*!
               \qmlmethod ChartView::removeSeries(AbstractSeries series)
               Removes the \a series from the chart. The series object is also destroyed.
             */
             /*!
               \qmlmethod ChartView::removeAllSeries()
               Removes all series from the chart. All the series objects are also destroyed.
             */
             /*!
               \qmlmethod Axis ChartView::axisX(AbstractSeries series)
               The x-axis of the series.
             */
             /*!
               \qmlmethod Axis ChartView::axisY(AbstractSeries series)
               The y-axis of the series.
             */
             /*!
               \qmlmethod ChartView::zoomY(real factor)
               Zooms in by \a factor on the center of the chart.
             */
             /*!
               \qmlmethod ChartView::scrollLeft(real pixels)
               Scrolls to left by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod ChartView::scrollRight(real pixels)
               Scrolls to right by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod ChartView::scrollUp(real pixels)
               Scrolls up by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlmethod ChartView::scrollDown(real pixels)
               Scrolls down by \a pixels. This is a convenience function that suits for example for key navigation.
             */
             /*!
               \qmlsignal ChartView::seriesAdded(AbstractSeries series)
               The \a series has been added to the chart.
             */
             /*!
               \qmlsignal ChartView::seriesRemoved(AbstractSeries series)
               The \a series has been removed from the chart. Please note that \a series is no longer a valid
               object after the signal handler has completed.
             */
             DeclarativeChart::DeclarativeChart(QQuickItem *parent)
                 : QQuickPaintedItem(parent)
             {
                 initChart(QChart::ChartTypeCartesian);
             }
             DeclarativeChart::DeclarativeChart(QChart::ChartType type, QQuickItem *parent)
                 : QQuickPaintedItem(parent)
             {
                 initChart(type);
             }
             void DeclarativeChart::initChart(QChart::ChartType type)
             {
                 m_currentSceneImage = 0;
                 m_guiThreadId = QThread::currentThreadId();
                 m_paintThreadId = 0;
                 m_updatePending = false;
                 if (type == QChart::ChartTypePolar)
                     m_chart = new QPolarChart();
                 else
                     m_chart = new QChart();
                 m_scene = new QGraphicsScene(this);
                 m_scene->addItem(m_chart);
                 setAntialiasing(QQuickItem::antialiasing());
                 connect(m_scene, SIGNAL(changed(QList<QRectF>)), this, SLOT(sceneChanged(QList<QRectF>)));
                 connect(this, SIGNAL(antialiasingChanged(bool)), this, SLOT(handleAntialiasingChanged(bool)));
                 setAcceptedMouseButtons(Qt::AllButtons);
                 setAcceptHoverEvents(true);
                 m_margins = new DeclarativeMargins(this);
                 m_margins->setTop(m_chart->margins().top());
                 m_margins->setLeft(m_chart->margins().left());
                 m_margins->setRight(m_chart->margins().right());
                 m_margins->setBottom(m_chart->margins().bottom());
                 connect(m_margins, SIGNAL(topChanged(int,int,int,int)), this, SLOT(changeMinimumMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(bottomChanged(int,int,int,int)), this, SLOT(changeMinimumMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(leftChanged(int,int,int,int)), this, SLOT(changeMinimumMargins(int,int,int,int)));
                 connect(m_margins, SIGNAL(rightChanged(int,int,int,int)), this, SLOT(changeMinimumMargins(int,int,int,int)));
                 connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), this, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), this, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 connect(m_chart, &QChart::plotAreaChanged, this, &DeclarativeChart::plotAreaChanged);
             }
             void DeclarativeChart::handleSeriesAdded(QAbstractSeries *series)
             {
                 emit seriesAdded(series);
             }
             void DeclarativeChart::changeMinimumMargins(int top, int bottom, int left, int right)
             {
                 m_chart->setMargins(QMargins(left, top, right, bottom));
                 emit minimumMarginsChanged();
             }
             DeclarativeChart::~DeclarativeChart()
             {
                 delete m_chart;
                 m_sceneImageLock.lock();
                 delete m_currentSceneImage;
                 m_currentSceneImage = 0;
                 m_sceneImageLock.unlock();
             }
             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)) {
                         // Add series to the chart
                         QAbstractSeries *series = qobject_cast<QAbstractSeries *>(child);
                         m_chart->addSeries(series);
                         // Connect to axis changed signals (unless this is a pie series)
                         if (!qobject_cast<DeclarativePieSeries *>(series)) {
                             connect(series, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SLOT(handleAxisXTopSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                             connect(series, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SLOT(handleAxisYRightSet(QAbstractAxis*)));
                         }
                         initializeAxes(series);
                     }
                 }
                 QQuickItem::componentComplete();
             }
             void DeclarativeChart::seriesAxisAttachHelper(QAbstractSeries *series, QAbstractAxis *axis,
                                                           Qt::Orientations orientation,
                                                           Qt::Alignment alignment)
             {
                 if (!series->attachedAxes().contains(axis)) {
                     // Remove & delete old axes that are not attached to any other series
                     foreach (QAbstractAxis* oldAxis, m_chart->axes(orientation, series)) {
                         bool otherAttachments = false;
                         if (oldAxis != axis) {
                             foreach (QAbstractSeries *oldSeries, m_chart->series()) {
                                 if (oldSeries != series && oldSeries->attachedAxes().contains(oldAxis)) {
                                     otherAttachments = true;
                                     break;
                                 }
                             }
                             if (!otherAttachments) {
                                 m_chart->removeAxis(oldAxis);
                                 delete oldAxis;
                             }
                         }
                     }
                     if (!m_chart->axes(orientation).contains(axis))
                         m_chart->addAxis(axis, alignment);
                     series->attachAxis(axis);
                 }
             }
             void DeclarativeChart::handleAxisXSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Horizontal, Qt::AlignBottom);
                 } else {
                     qWarning() << "Trying to set axisX to null.";
                 }
             }
             void DeclarativeChart::handleAxisXTopSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Horizontal, Qt::AlignTop);
                 } else {
                     qWarning() << "Trying to set axisXTop to null.";
                 }
             }
             void DeclarativeChart::handleAxisYSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Vertical, Qt::AlignLeft);
                 } else {
                     qWarning() << "Trying to set axisY to null.";
                 }
             }
             void DeclarativeChart::handleAxisYRightSet(QAbstractAxis *axis)
             {
                 QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender());
                 if (axis && s) {
                     seriesAxisAttachHelper(s, axis, Qt::Vertical, Qt::AlignRight);
                 } else {
                     qWarning() << "Trying to set axisYRight to null.";
                 }
             }
             void DeclarativeChart::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
             {
                 if (newGeometry.isValid()) {
                     if (newGeometry.width() > 0 && newGeometry.height() > 0) {
                         m_chart->resize(newGeometry.width(), newGeometry.height());
                     }
                 }
                 QQuickItem::geometryChanged(newGeometry, oldGeometry);
             }
             void DeclarativeChart::sceneChanged(QList<QRectF> region)
             {
                 Q_UNUSED(region);
                 if (m_guiThreadId == m_paintThreadId) {
                     // Rendering in gui thread, no need for shenannigans, just update
                     update();
                 } else {
                     // Multi-threaded rendering, need to ensure scene is actually rendered in gui thread
                     if (!m_updatePending) {
                         m_updatePending = true;
                         // Do async render to avoid some unnecessary renders.
                         QTimer::singleShot(0, this, SLOT(renderScene()));
                     }
                 }
             }
             void DeclarativeChart::renderScene()
             {
                 m_updatePending = false;
                 m_sceneImageLock.lock();
                 delete m_currentSceneImage;
                 m_currentSceneImage = new QImage(m_chart->size().toSize(), QImage::Format_ARGB32);
                 m_currentSceneImage->fill(Qt::transparent);
                 QPainter painter(m_currentSceneImage);
                 if (antialiasing())
                     painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform);
                 QRect renderRect(QPoint(0, 0), m_chart->size().toSize());
                 m_scene->render(&painter, renderRect, renderRect);
                 m_sceneImageLock.unlock();
                 update();
             }
             void DeclarativeChart::paint(QPainter *painter)
             {
                 if (!m_paintThreadId) {
                     m_paintThreadId = QThread::currentThreadId();
                     if (m_guiThreadId == m_paintThreadId) {
                         // No need for scene image in single threaded rendering, so delete
                         // the one that got made by default before the rendering type was
                         // detected.
                         delete m_currentSceneImage;
                         m_currentSceneImage = 0;
                     }
                 }
                 if (m_guiThreadId == m_paintThreadId) {
                     QRectF renderRect(QPointF(0, 0), m_chart->size());
                     m_scene->render(painter, renderRect, renderRect);
                 } else {
                     m_sceneImageLock.lock();
                     if (m_currentSceneImage) {
                         QRect imageRect(QPoint(0, 0), m_currentSceneImage->size());
                         QRect itemRect(QPoint(0, 0), QSize(width(), height()));
                         painter->drawImage(itemRect, *m_currentSceneImage, imageRect);
                     }
                     m_sceneImageLock.unlock();
                 }
             }
             void DeclarativeChart::mousePressEvent(QMouseEvent *event)
             {
                 m_mousePressScenePoint = event->pos();
                 m_mousePressScreenPoint = event->globalPos();
                 m_lastMouseMoveScenePoint = m_mousePressScenePoint;
                 m_lastMouseMoveScreenPoint = m_mousePressScreenPoint;
                 m_mousePressButton = event->button();
                 m_mousePressButtons = event->buttons();
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMousePress);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(m_mousePressScenePoint);
                 mouseEvent.setScreenPos(m_mousePressScreenPoint);
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(m_mousePressButtons);
                 mouseEvent.setButton(m_mousePressButton);
                 mouseEvent.setModifiers(event->modifiers());
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
             }
             void DeclarativeChart::mouseReleaseEvent(QMouseEvent *event)
             {
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseRelease);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(event->pos());
                 mouseEvent.setScreenPos(event->globalPos());
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(event->buttons());
                 mouseEvent.setButton(event->button());
                 mouseEvent.setModifiers(event->modifiers());
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
                 m_mousePressButtons = event->buttons();
                 m_mousePressButton = Qt::NoButton;
             }
             void DeclarativeChart::hoverMoveEvent(QHoverEvent *event)
             {
                 // Convert hover move to mouse move, since we don't seem to get actual mouse move events.
                 // QGraphicsScene generates hover events from mouse move events, so we don't need
                 // to pass hover events there.
                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseMove);
                 mouseEvent.setWidget(0);
                 mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint);
                 mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint);
                 mouseEvent.setScenePos(event->pos());
                 // Hover events do not have global pos in them, and the screen position doesn't seem to
                 // matter anyway in this use case, so just pass event pos instead of trying to
                 // calculate the real screen position.
                 mouseEvent.setScreenPos(event->pos());
                 mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint);
                 mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint);
                 mouseEvent.setButtons(m_mousePressButtons);
                 mouseEvent.setButton(m_mousePressButton);
                 mouseEvent.setModifiers(event->modifiers());
                 m_lastMouseMoveScenePoint = mouseEvent.scenePos();
                 m_lastMouseMoveScreenPoint = mouseEvent.screenPos();
                 mouseEvent.setAccepted(false);
                 QApplication::sendEvent(m_scene, &mouseEvent);
             }
             void DeclarativeChart::handleAntialiasingChanged(bool enable)
             {
                 setAntialiasing(enable);
             }
             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();
             }
             QAbstractAxis *DeclarativeChart::axisX(QAbstractSeries *series)
             {
                 QList<QAbstractAxis *> axes = m_chart->axes(Qt::Horizontal, series);
                 if (axes.count())
                     return axes[0];
                 return 0;
             }
             QAbstractAxis *DeclarativeChart::axisY(QAbstractSeries *series)
             {
                 QList<QAbstractAxis *> axes = m_chart->axes(Qt::Vertical, series);
                 if (axes.count())
                     return axes[0];
                 return 0;
             }
             QLegend *DeclarativeChart::legend()
             {
                 return m_chart->legend();
             }
             void DeclarativeChart::setTitleColor(QColor color)
             {
                 QBrush b = m_chart->titleBrush();
                 if (color != b.color()) {
                     b.setColor(color);
                     m_chart->setTitleBrush(b);
                     emit titleColorChanged(color);
                 }
             }
             QFont DeclarativeChart::titleFont() const
             {
                 return m_chart->titleFont();
             }
             void DeclarativeChart::setTitleFont(const QFont &font)
             {
                 m_chart->setTitleFont(font);
             }
             QColor DeclarativeChart::titleColor()
             {
                 return m_chart->titleBrush().color();
             }
             void DeclarativeChart::setBackgroundColor(QColor color)
             {
                 QBrush b = m_chart->backgroundBrush();
                 if (b.style() != Qt::SolidPattern || color != b.color()) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setBackgroundBrush(b);
                     emit backgroundColorChanged();
                 }
             }
             QColor DeclarativeChart::backgroundColor()
             {
                 return m_chart->backgroundBrush().color();
             }
             void QtCharts::DeclarativeChart::setPlotAreaColor(QColor color)
             {
                 QBrush b = m_chart->plotAreaBackgroundBrush();
                 if (b.style() != Qt::SolidPattern || color != b.color()) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setPlotAreaBackgroundBrush(b);
                     m_chart->setPlotAreaBackgroundVisible(true);
                     emit plotAreaColorChanged();
                 }
             }
             QColor QtCharts::DeclarativeChart::plotAreaColor()
             {
                 return m_chart->plotAreaBackgroundBrush().color();
             }
             void DeclarativeChart::setLocalizeNumbers(bool localize)
             {
                 if (m_chart->localizeNumbers() != localize) {
                     m_chart->setLocalizeNumbers(localize);
                     emit localizeNumbersChanged();
                 }
             }
             bool DeclarativeChart::localizeNumbers() const
             {
                 return m_chart->localizeNumbers();
             }
             void QtCharts::DeclarativeChart::setLocale(const QLocale &locale)
             {
                 if (m_chart->locale() != locale) {
                     m_chart->setLocale(locale);
                     emit localeChanged();
                 }
             }
             QLocale QtCharts::DeclarativeChart::locale() const
             {
                 return m_chart->locale();
             }
             int DeclarativeChart::count()
             {
                 return m_chart->series().count();
             }
             void DeclarativeChart::setDropShadowEnabled(bool enabled)
             {
                 if (enabled != m_chart->isDropShadowEnabled()) {
                     m_chart->setDropShadowEnabled(enabled);
                     dropShadowEnabledChanged(enabled);
                 }
             }
             bool DeclarativeChart::dropShadowEnabled()
             {
                 return m_chart->isDropShadowEnabled();
             }
             qreal DeclarativeChart::backgroundRoundness() const
             {
                 return m_chart->backgroundRoundness();
             }
             void DeclarativeChart::setBackgroundRoundness(qreal diameter)
             {
                 if (m_chart->backgroundRoundness() != diameter) {
                     m_chart->setBackgroundRoundness(diameter);
                     emit backgroundRoundnessChanged(diameter);
                 }
             }
             qreal DeclarativeChart::topMargin()
             {
                 qWarning() << "ChartView.topMargin is deprecated. Use margins instead.";
                 return m_chart->margins().top();
             }
             qreal DeclarativeChart::bottomMargin()
             {
                 qWarning() << "ChartView.bottomMargin is deprecated. Use margins instead.";
                 return m_chart->margins().bottom();
             }
             qreal DeclarativeChart::leftMargin()
             {
                 qWarning() << "ChartView.leftMargin is deprecated. Use margins instead.";
                 return m_chart->margins().left();
             }
             qreal DeclarativeChart::rightMargin()
             {
                 qWarning() << "ChartView.rightMargin is deprecated. Use margins instead.";
                 return m_chart->margins().right();
             }
             void DeclarativeChart::zoom(qreal factor)
             {
                 m_chart->zoom(factor);
             }
             void DeclarativeChart::scrollLeft(qreal pixels)
             {
                 m_chart->scroll(-pixels, 0);
             }
             void DeclarativeChart::scrollRight(qreal pixels)
             {
                 m_chart->scroll(pixels, 0);
             }
             void DeclarativeChart::scrollUp(qreal pixels)
             {
                 m_chart->scroll(0, pixels);
             }
             void DeclarativeChart::scrollDown(qreal pixels)
             {
                 m_chart->scroll(0, -pixels);
             }
             QQmlListProperty<QAbstractAxis> DeclarativeChart::axes()
             {
                 return QQmlListProperty<QAbstractAxis>(this, 0,
                             &DeclarativeChart::axesAppendFunc,
                             &DeclarativeChart::axesCountFunc,
                             &DeclarativeChart::axesAtFunc,
                             &DeclarativeChart::axesClearFunc);
             }
             void DeclarativeChart::axesAppendFunc(QQmlListProperty<QAbstractAxis> *list, QAbstractAxis *element)
             {
                 // Empty implementation
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             int DeclarativeChart::axesCountFunc(QQmlListProperty<QAbstractAxis> *list)
             {
                 if (qobject_cast<DeclarativeChart *>(list->object)) {
                     DeclarativeChart *chart = qobject_cast<DeclarativeChart *>(list->object);
                     return chart->m_chart->axes(Qt::Horizontal | Qt::Vertical).count();
                 }
                 return 0;
             }
             QAbstractAxis *DeclarativeChart::axesAtFunc(QQmlListProperty<QAbstractAxis> *list, int index)
             {
                 if (qobject_cast<DeclarativeChart *>(list->object)) {
                     DeclarativeChart *chart = qobject_cast<DeclarativeChart *>(list->object);
                     QList<QAbstractAxis *> axes = chart->m_chart->axes(Qt::Horizontal | Qt::Vertical, chart->m_chart->series()[0]);
                     return axes.at(index);
                 }
                 return 0;
             }
             void DeclarativeChart::axesClearFunc(QQmlListProperty<QAbstractAxis> *list)
             {
                 // Empty implementation
                 Q_UNUSED(list);
             }
             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(int type, QString name, QAbstractAxis *axisX, QAbstractAxis *axisY)
             {
                 QAbstractSeries *series = 0;
                 switch (type) {
                 case DeclarativeChart::SeriesTypeLine:
                     series = new DeclarativeLineSeries();
                     break;
                 case DeclarativeChart::SeriesTypeArea: {
                     DeclarativeAreaSeries *area = new DeclarativeAreaSeries();
                     area->setUpperSeries(new DeclarativeLineSeries());
                     series = area;
                     break;
                 }
                 case DeclarativeChart::SeriesTypeStackedBar:
                     series = new DeclarativeStackedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypePercentBar:
                     series = new DeclarativePercentBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBar:
                     series = new DeclarativeBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalBar:
                     series = new DeclarativeHorizontalBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalPercentBar:
                     series = new DeclarativeHorizontalPercentBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeHorizontalStackedBar:
                     series = new DeclarativeHorizontalStackedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBoxPlot:
                     series = new DeclarativeBoxPlotSeries();
                     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";
                 }
                 if (series) {
                     // Connect to axis changed signals (unless this is a pie series)
                     if (!qobject_cast<DeclarativePieSeries *>(series)) {
                         connect(series, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                         connect(series, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*)));
                         connect(series, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*)));
                         connect(series, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SLOT(handleAxisYRightSet(QAbstractAxis*)));
                     }
                     series->setName(name);
                     m_chart->addSeries(series);
                     if (!axisX || !axisY)
                         initializeAxes(series);
                     if (axisX)
                         setAxisX(axisX, series);
                     if (axisY)
                         setAxisY(axisY, series);
                 }
                 return series;
             }
             void DeclarativeChart::removeSeries(QAbstractSeries *series)
             {
                 if (series)
                     m_chart->removeSeries(series);
                 else
                     qWarning("removeSeries: cannot remove null");
             }
             void DeclarativeChart::setAxisX(QAbstractAxis *axis, QAbstractSeries *series)
             {
                 if (axis && series)
                     seriesAxisAttachHelper(series, axis, Qt::Horizontal, Qt::AlignBottom);
             }
             void DeclarativeChart::setAxisY(QAbstractAxis *axis, QAbstractSeries *series)
             {
                 if (axis && series)
                     seriesAxisAttachHelper(series, axis, Qt::Vertical, Qt::AlignLeft);
             }
             void DeclarativeChart::createDefaultAxes()
             {
                 qWarning() << "ChartView.createDefaultAxes() is deprecated. Axes are created automatically.";
             }
             QAbstractAxis *DeclarativeChart::defaultAxis(Qt::Orientation orientation, QAbstractSeries *series)
             {
                 if (!series) {
                     qWarning() << "No axis type defined for null series";
                     return 0;
                 }
                 foreach (QAbstractAxis *existingAxis, m_chart->axes(orientation)) {
                     if (existingAxis->type() == series->d_ptr->defaultAxisType(orientation))
                         return existingAxis;
                 }
                 switch (series->d_ptr->defaultAxisType(orientation)) {
                 case QAbstractAxis::AxisTypeValue:
                     return new QValueAxis(this);
                 case QAbstractAxis::AxisTypeBarCategory:
                     return new QBarCategoryAxis(this);
                 case QAbstractAxis::AxisTypeCategory:
                     return new QCategoryAxis(this);
             #ifndef QT_ON_ARM
                 case QAbstractAxis::AxisTypeDateTime:
                     return new QDateTimeAxis(this);
             #endif
                 case QAbstractAxis::AxisTypeLogValue:
                     return new QLogValueAxis(this);
                 default:
                     // assume AxisTypeNoAxis
                     return 0;
                 }
             }
             void DeclarativeChart::initializeAxes(QAbstractSeries *series)
             {
                 if (qobject_cast<DeclarativeLineSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeLineSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeScatterSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeScatterSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeSplineSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeSplineSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeAreaSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeAreaSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeStackedBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeStackedBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativePercentBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativePercentBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeHorizontalBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeHorizontalBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeHorizontalStackedBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeHorizontalStackedBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeHorizontalPercentBarSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeHorizontalPercentBarSeries *>(series)->m_axes);
                 else if (qobject_cast<DeclarativeBoxPlotSeries *>(series))
                     doInitializeAxes(series, qobject_cast<DeclarativeBoxPlotSeries *>(series)->m_axes);
                 // else: do nothing
             }
             void DeclarativeChart::doInitializeAxes(QAbstractSeries *series, DeclarativeAxes *axes)
             {
                 // Initialize axis X
                 if (axes->axisX())
                     axes->emitAxisXChanged();
                 else if (axes->axisXTop())
                     axes->emitAxisXTopChanged();
                 else
                     axes->setAxisX(defaultAxis(Qt::Horizontal, series));
                 // Initialize axis Y
                 if (axes->axisY())
                     axes->emitAxisYChanged();
                 else if (axes->axisYRight())
                     axes->emitAxisYRightChanged();
                 else
                     axes->setAxisY(defaultAxis(Qt::Vertical, series));
             }
             #include "moc_declarativechart.cpp"
             QT_CHARTS_END_NAMESPACE

src/chartsqml2/declarativemargins.cpp +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2014 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 "declarativemargins.h"
             #include <QtCore/QDataStream>
             #include <QtCore/QDebug>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \qmltype Margins
                 \inqmlmodule QtCharts
+                \brief Type is used to define margins.
                 Uncreatable type that is used to define top, bottom, left and right margins.
             */
             /*!
                 \qmlproperty int Margins::top
                 The top margin.
             */
             /*!
                 \qmlproperty int Margins::bottom
                 The bottom margin.
             */
             /*!
                 \qmlproperty int Margins::left
                 The left margin.
             */
             /*!
                 \qmlproperty int Margins::right
                 The right margin.
             */
             DeclarativeMargins::DeclarativeMargins(QObject *parent) :
                 QObject(parent)
             {
                 QMargins::setTop(0);
                 QMargins::setBottom(0);
                 QMargins::setLeft(0);
                 QMargins::setRight(0);
             }
             void DeclarativeMargins::setTop(int top)
             {
                 if (top < 0) {
                     qWarning() << "Cannot set top margin to a negative value:" << top;
                 } else {
                     if (top != QMargins::top()) {
                         QMargins::setTop(top);
                         emit topChanged(QMargins::top(), QMargins::bottom(), QMargins::left(), QMargins::right());
                     }
                 }
             }
             void DeclarativeMargins::setBottom(int bottom)
             {
                 if (bottom < 0) {
                     qWarning() << "Cannot set bottom margin to a negative value:" << bottom;
                 } else {
                     if (bottom != QMargins::bottom()) {
                         QMargins::setBottom(bottom);
                         emit bottomChanged(QMargins::top(), QMargins::bottom(), QMargins::left(), QMargins::right());
                     }
                 }
             }
             void DeclarativeMargins::setLeft(int left)
             {
                 if (left < 0) {
                     qWarning() << "Cannot set left margin to a negative value:" << left;
                 } else {
                     if (left != QMargins::left()) {
                         QMargins::setLeft(left);
                         emit leftChanged(QMargins::top(), QMargins::bottom(), QMargins::left(), QMargins::right());
                     }
                 }
             }
             void DeclarativeMargins::setRight(int right)
             {
                 if (right < 0) {
                     qWarning() << "Cannot set left margin to a negative value:" << right;
                 } else {
                     if (right != QMargins::right()) {
                         QMargins::setRight(right);
                         emit rightChanged(QMargins::top(), QMargins::bottom(), QMargins::left(), QMargins::right());
                     }
                 }
             }
             #include "moc_declarativemargins.cpp"
             QT_CHARTS_END_NAMESPACE

src/chartsqml2/declarativepolarchart.cpp +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2014 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 "declarativepolarchart.h"
             #include <QtCharts/QChart>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \qmltype PolarChartView
                 \instantiates DeclarativePolarChart
                 \inqmlmodule QtCharts
+                \brief Polar chart element.
                 PolarChartView element is the parent that is responsible for showing different chart series
                 types in a polar chart.
                 Polar charts support line, spline, area, and scatter series, and all axis types
                 supported by those series.
                 \note When setting ticks to an angular ValueAxis, keep in mind that the first and last tick
                 are co-located at 0/360 degree angle.
                 \note If the angular distance between two consecutive points in a series is more than 180
                 degrees, any line connecting the two points becomes meaningless, so choose the axis ranges
                 accordingly when displaying line, spline, or area series.
                 The following QML shows how to create a polar chart with two series:
                 \snippet qmlpolarchart/qml/qmlpolarchart/View1.qml 1
                 \beginfloatleft
                 \image examples_qmlpolarchart1.png
                 \endfloat
                 \clearfloat
             */
             DeclarativePolarChart::DeclarativePolarChart(QQuickItem *parent)
                 : DeclarativeChart(QChart::ChartTypePolar, parent)
             {
             }
             DeclarativePolarChart::~DeclarativePolarChart()
             {
             }
             #include "moc_declarativepolarchart.cpp"
             QT_CHARTS_END_NAMESPACE

src/chartsqml2/declarativexypoint.cpp +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2014 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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"
             #include <QtCore/QDataStream>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \qmltype XYPoint
                 \inqmlmodule QtCharts
+                \brief Type is used to initialize XY-series coordinate data.
                 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"
             QT_CHARTS_END_NAMESPACE

General Comments 0

Write
Preview

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

No TODOs yet

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

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