HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2750:0968736234d9

Fix documentation appearance...

Titta Heikkala -

r2750:0968736234d9

parent child

Context file:

r2750:0968736234d9

Collapse all files

src/charts/axis/categoryaxis/qcategoryaxis.cpp +18 -30

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             #include <QtCharts/QCategoryAxis>
             #include <private/qcategoryaxis_p.h>
             #include <private/chartcategoryaxisx_p.h>
             #include <private/chartcategoryaxisy_p.h>
             #include <private/polarchartcategoryaxisangular_p.h>
             #include <private/polarchartcategoryaxisradial_p.h>
             #include <QtCharts/QChart>
             #include <QtCore/QtMath>
             #include <QtCore/QDebug>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QCategoryAxis
                 \inmodule Qt Charts
                 \brief The QCategoryAxis class allows putting a named ranges on the axis.
                 \mainclass
                 This class can be used when the underlying data needs to be given extra meaning.
                 Unlike with the QBarCategoryAxis the QCategoryAxis allows the categories ranges widths to be specified freely.
                 Example code on how to use QCategoryAxis:
-                \table
+                \image api_category_axis.png
-                    \row
+                \code
-                        \li  \br
+                QChartView *chartView = new QChartView;
-                            \br
+                QLineSeries *series = new QLineSeries;
-                            \code
+                // ...
-                            QChartView *chartView = new QChartView;
+                chartView->chart()->addSeries(series);
-                            QLineSeries *series = new QLineSeries;
-                            // ...
+                QCategoryAxis *axisY = new QCategoryAxis;
-                            chartView->chart()->addSeries(series);
+                axisY->setMin(0);
+                axisY->setMax(52);
-                            QCategoryAxis *axisY = new QCategoryAxis;
+                axisY->setStartValue(15);
-                            axisY->setMin(0);
+                axisY->append("First", 20);
-                            axisY->setMax(52);
+                axisY->append("Second", 37);
-                            axisY->setStartValue(15);
+                axisY->append("Third", 52);
-                            axisY->append("First", 20);
+                chartView->chart()->setAxisY(axisY, series);
-                            axisY->append("Second", 37);
+                \endcode
-                            axisY->append("Third", 52);
-                            chartView->chart()->setAxisY(axisY, series);
-                            \endcode
-                        \li \br
-                           \inlineimage api_category_axis.png
-                \endtable
             */
             /*!
                 \qmltype CategoryAxis
                 \instantiates QCategoryAxis
                 \inqmlmodule QtCharts
                 \inherits AbstractAxis
                 \brief CategoryAxis allows putting a named ranges on the axis.
                 For example:
-                \table
+                \image examples_qmlaxes3.png
-                    \row
+                \snippet qmlaxes/qml/qmlaxes/View3.qml 1
-                        \li \br
-                            \br
-                            \br
-                            \snippet qmlaxes/qml/qmlaxes/View3.qml 1
-                        \li \inlineimage examples_qmlaxes3.png
-                \endtable
             */
             /*!
               \property QCategoryAxis::startValue
               Defines the low end of the first category on the axis.
             */
             /*!
               \qmlproperty int CategoryAxis::startValue
               Defines the low end of the first category on the axis.
             */
             /*!
               \property QCategoryAxis::count
               The count of categories.
             */
             /*!
               \qmlproperty int CategoryAxis::count
               The count of categories.
             */
             /*!
               \property QCategoryAxis::categoriesLabels
               The category labels as a string list.
             */
             /*!
               \qmlproperty StringList CategoryAxis::categoriesLabels
               The category labels as a list of strings.
             */
             /*!
               \fn void QCategoryAxis::categoriesChanged()
               Axis emits signal when the categories of the axis have changed.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QCategoryAxis::QCategoryAxis(QObject *parent):
                 QValueAxis(*new QCategoryAxisPrivate(this), parent)
             {
             }
             /*!
                 Destroys the object
             */
             QCategoryAxis::~QCategoryAxis()
             {
                 Q_D(QCategoryAxis);
                 if (d->m_chart)
                     d->m_chart->removeAxis(this);
             }
             /*!
                 \internal
             */
             QCategoryAxis::QCategoryAxis(QCategoryAxisPrivate &d, QObject *parent): QValueAxis(d, parent)
             {
             }
             /*!
                 \qmlmethod CategoryAxis::append(string label, real endValue)
                 Appends new category to the axis with an \a label. Category label has to be unique.
                 Parameter \a endValue specifies the high end limit of the category.
                 It has to be greater than the high end limit of the previous category.
                 Otherwise the method returns without adding a new category.
             */
             /*!
                 Appends new category to the axis with an \a categoryLabel.
                 Category label has to be unique.
                 Parameter \a categoryEndValue specifies the high end limit of the category.
                 It has to be greater than the high end limit of the previous category.
                 Otherwise the method returns without adding a new category.
             */
             void QCategoryAxis::append(const QString &categoryLabel, qreal categoryEndValue)
             {
                 Q_D(QCategoryAxis);
                 if (!d->m_categories.contains(categoryLabel)) {
                     if (d->m_categories.isEmpty()) {
                         Range range(d->m_categoryMinimum, categoryEndValue);
                         d->m_categoriesMap.insert(categoryLabel, range);
                         d->m_categories.append(categoryLabel);
                         emit categoriesChanged();
                     } else if (categoryEndValue > endValue(d->m_categories.last())) {
                         Range previousRange = d->m_categoriesMap.value(d->m_categories.last());
                         d->m_categoriesMap.insert(categoryLabel, Range(previousRange.second, categoryEndValue));
                         d->m_categories.append(categoryLabel);
                         emit categoriesChanged();
                     }
                 }
             }
             /*!
                 Sets \a min to be the low end limit of the first category on the axis.
                 If there is already some categories added to the axis then passed value must be lower than the high end value of the already defined first category range.
                 Otherwise nothing is done.
             */
             void QCategoryAxis::setStartValue(qreal min)
             {
                 Q_D(QCategoryAxis);
                 if (d->m_categories.isEmpty()) {
                     d->m_categoryMinimum = min;
                     emit categoriesChanged();
                 } else {
                     Range range = d->m_categoriesMap.value(d->m_categories.first());
                     if (min < range.second) {
                         d->m_categoriesMap.insert(d->m_categories.first(), Range(min, range.second));
                         emit categoriesChanged();
                     }
                 }
             }
             /*!
                 Returns the low end limit of the category specified by an \a categoryLabel
             */
             qreal QCategoryAxis::startValue(const QString &categoryLabel) const
             {
                 Q_D(const QCategoryAxis);
                 if (categoryLabel.isEmpty())
                     return d->m_categoryMinimum;
                 return d->m_categoriesMap.value(categoryLabel).first;
             }
             /*!
                 Returns the high end limit of the interval specified by an \a categoryLabel
             */
             qreal QCategoryAxis::endValue(const QString &categoryLabel) const
             {
                 Q_D(const QCategoryAxis);
                 return d->m_categoriesMap.value(categoryLabel).second;
             }
             /*!
                 \qmlmethod CategoryAxis::remove(string label)
                 Removes a category specified by the \a label from the axis
             */
             /*!
                 Removes an interval specified by the \a categoryLabel from the axis
             */
             void QCategoryAxis::remove(const QString &categoryLabel)
             {
                 Q_D(QCategoryAxis);
                 int labelIndex = d->m_categories.indexOf(categoryLabel);
                 // check if such label exists
                 if (labelIndex != -1) {
                     d->m_categories.removeAt(labelIndex);
                     d->m_categoriesMap.remove(categoryLabel);
                     // the range of the interval that follows (if exists) needs to be updated
                     if (labelIndex < d->m_categories.count()) {
                         QString label = d->m_categories.at(labelIndex);
                         Range range = d->m_categoriesMap.value(label);
                         // set the range
                         if (labelIndex == 0) {
                             range.first = d->m_categoryMinimum;
                             d->m_categoriesMap.insert(label, range);
                         } else {
                             range.first = d->m_categoriesMap.value(d->m_categories.at(labelIndex - 1)).second;
                             d->m_categoriesMap.insert(label, range);
                         }
                     }
                     emit categoriesChanged();
                 }
             }
             /*!
               \qmlmethod CategoryAxis::replace(string oldLabel, string newLabel)
               Replaces \a oldLabel of an existing category with a \a newLabel.
               If the old label does not exist the method returns without making any changes.
             */
             /*!
               Replaces \a oldLabel of an existing category with a \a newLabel
               If the old label does not exist the method returns without making any changes.
              */
             void QCategoryAxis::replaceLabel(const QString &oldLabel, const QString &newLabel)
             {
                 Q_D(QCategoryAxis);
                 int labelIndex = d->m_categories.indexOf(oldLabel);
                 // check if such label exists
                 if (labelIndex != -1) {
                     d->m_categories.replace(labelIndex, newLabel);
                     Range range = d->m_categoriesMap.value(oldLabel);
                     d->m_categoriesMap.remove(oldLabel);
                     d->m_categoriesMap.insert(newLabel, range);
                     emit categoriesChanged();
                 }
             }
             /*!
               Returns the list of the intervals labels
              */
             QStringList QCategoryAxis::categoriesLabels()
             {
                 Q_D(QCategoryAxis);
                 return d->m_categories;
             }
             /*!
               Returns number of intervals.
              */
             int QCategoryAxis::count() const
             {
                 Q_D(const QCategoryAxis);
                 return d->m_categories.count();
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QCategoryAxis::type() const
             {
                 return QAbstractAxis::AxisTypeCategory;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QCategoryAxisPrivate::QCategoryAxisPrivate(QCategoryAxis *q)
                 : QValueAxisPrivate(q),
                   m_categoryMinimum(0)
             {
             }
             QCategoryAxisPrivate::~QCategoryAxisPrivate()
             {
             }
             int QCategoryAxisPrivate::ticksCount() const
             {
                 return m_categories.count() + 1;
             }
             void QCategoryAxisPrivate::initializeGraphics(QGraphicsItem *parent)
             {
                 Q_Q(QCategoryAxis);
                 ChartAxisElement *axis(0);
                 if (m_chart->chartType() == QChart::ChartTypeCartesian) {
                     if (orientation() == Qt::Vertical)
                         axis = new ChartCategoryAxisY(q,parent);
                     else if (orientation() == Qt::Horizontal)
                         axis = new ChartCategoryAxisX(q,parent);
                 }
                 if (m_chart->chartType() == QChart::ChartTypePolar) {
                     if (orientation() == Qt::Vertical)
                         axis = new PolarChartCategoryAxisRadial(q, parent);
                     if (orientation() == Qt::Horizontal)
                         axis = new PolarChartCategoryAxisAngular(q, parent);
                 }
                 m_item.reset(axis);
                 QAbstractAxisPrivate::initializeGraphics(parent);
             }
             #include "moc_qcategoryaxis.cpp"
             #include "moc_qcategoryaxis_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/doc/src/examples-audio.qdoc +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                  \example audio
-                 \title Audio example
+                 \title Audio Example
                  \ingroup qtcharts_examples
                  \brief This example shows the drawing of dynamic data (microphone input).
                  \image examples_audio.png
             */

src/charts/doc/src/examples-barmodelmapper.qdoc +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                  \example barmodelmapper
-                 \title BarModelMapper example
+                 \title BarModelMapper Example
                  \ingroup qtcharts_examples
                  \brief This example shows how to use QAbstractItemModel derived model as the data for the bar
                  series.
                  \image examples_barmodelmapper.png
                  Let's start by creating an instance of CustomTableModel class.
                  The CustomTableModel class is derived from QAbstractTableModel, and it was created for the purpose of this example.
                  The constructor of this class populates the model's internal data store with the data required for our chart example.
                  \snippet barmodelmapper/tablewidget.cpp 1
                  We now have a model with data that we would like to display both on the chart and in a QTableView.
                  First, we create QTableView and tell it to use the model as a data source. To have the data presented nicely, the minimum width of the table view is set and its headers resize mode changed to stretch.
                  \snippet barmodelmapper/tablewidget.cpp 2
                  Now we need a QChart instance to display the same data on the chart.
                  We also enable animations. It makes it easier to see how a modification to the model's data affects the chart.
                  \snippet barmodelmapper/tablewidget.cpp 3
                  The first line of the code below creates new bar series. Variables firstRow and rowCount are used to define a custom model mapping.
                  Custom mapping allows to take only part of the data from the model. In this case data from 5 rows starting with the row with the index 3.
                  The following three lines create an instance of the QVBarModelMapper class and specify that the data for the bar sets should be taken from the model's columns with indexes from 1 to 4 (inclusive).
                  To create a connection between the series and the model we set both of those objects to QVBarModelMapper.
                  Finally the series is added to the chart.
                  \snippet barmodelmapper/tablewidget.cpp 4
                  To show in QTableView which data corresponds with which bar set, this example uses table coloring.
                  When series is added to the chart, it is assigned a color based on the currently selected theme.
                  Code below extracts that color from the series and uses it to create colored QTableView.
                  Coloring of the view is not a part of the QChart functionality.
                  \snippet barmodelmapper/tablewidget.cpp 5
                  We would like to have categories placed on the chart's axis that describe what the data means.
                  Next snippet shows how to do that.
                  \snippet barmodelmapper/tablewidget.cpp 6
                  To avoid setting up the QGraphicsScene we use the QChartView class that does it for us. The QChart object pointer is used as a parameter of the QChartView constructor.
                  To make the render look nicer Antialiasing is turned on and the minimum size of the chartView widget is set.
                  \snippet barmodelmapper/tablewidget.cpp 7
                  Finally, we place both widgets in a layout and use the layout as the application layout.
                  \snippet barmodelmapper/tablewidget.cpp 8
                  The application is ready. Try modifying the data in the table view and see how it affects the chart.
             */

src/charts/doc/src/examples-callout.qdoc +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                  \example callout
-                 \title Callout example
+                 \title Callout Example
                  \ingroup qtcharts_examples
                  \brief This example shows how to draw an additional element (a callout) on top of the chart.
                  \image examples_callout.png
                  QChart class provides two methods that map between the scene coordinates and the series domain
                 (defined by the axes ranges).
                  QPointF QChart::mapToPosition(const QPointF &value, QAbstractSeries *series)
                  QPointF QChart::mapToValue(const QPointF &position, QAbstractSeries *series)
             */

src/charts/doc/src/examples-chartthemes.qdoc +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                 \example chartthemes
-                \title Chart themes example
+                \title Chart Themes Example
                 \ingroup qtcharts_examples
                 \brief The example shows the look and feel of the different built-in themes.
                 This example shows the look and feel of the different built-in themes for all supported chart
                 types. In order to give the result a more harmonious look, the background palette of the
                 application is customized to the theme selected.
                 \image examples_chartthemes_light.png
                 \image examples_chartthemes_brown_sand.png
                 \image examples_chartthemes_blue_cerulean.png
             */

src/charts/doc/src/examples-donutbreakdown.qdoc +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                  \example donutbreakdown
-                 \title Donut chart breakdown example
+                 \title Donut Chart Breakdown Example
                  \ingroup qtcharts_examples
                  \brief This example shows how to use create a donut breakdown chart using QPieSeries API.
                  \image examples_donutbreakdown.png
                  Let's start by defining some data for the chart.
                  \snippet donutbreakdown/main.cpp 1
                  Then we create a chart where we add the data. Note that this is our own chart derived from QChart.
                  \snippet donutbreakdown/main.cpp 2
                  Our own chart works in such a way that we create a main series in the constructor we create a main series,
                  which aggregates the data provided by the breakdown series. This is the piechart in the center.
                  \snippet donutbreakdown/donutbreakdownchart.cpp 1
                  When a breakdown series is added the data is used to create a slice in the main series and the
                  breakdown series itself is used to create a segment of a donut positioned so that it is aligned
                  with the corresponding slice in the main series.
                  \snippet donutbreakdown/donutbreakdownchart.cpp 2
                  Here's how the start and end angles for the donut segments are calculated.
                  \snippet donutbreakdown/donutbreakdownchart.cpp 3
                  The legend markers are customized to show the breakdown percentage. The markers for the main level slices are hidden.
                  \snippet donutbreakdown/donutbreakdownchart.cpp 4
                  Instead the main level slices show the percentage on the label.
                  \snippet donutbreakdown/mainslice.cpp 1
                  \snippet donutbreakdown/mainslice.cpp 2
                  Now that we have our chart defined, we can finally create a QChartView and show the chart.
                  \snippet donutbreakdown/main.cpp 3
             */

src/charts/doc/src/examples-dynamicspline.qdoc +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                  \example dynamicspline
-                 \title Dynamic spline example
+                 \title Dynamic Spline Example
                  \ingroup qtcharts_examples
                  \brief This example shows how to draw dynamic data.
                  \image examples_dynamicspline1.png
                  \image examples_dynamicspline2.png
             */

src/charts/doc/src/examples-legend.qdoc +2 -5

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                 \example legend
                 \title Legend Example
                 \ingroup qtcharts_examples
                 \brief This example shows how to detach the legend from the chart and how to attach it back.
                 By default the chart draws the legend inside the same view with the chart. In some cases the
                 user may want to draw the legend to somewhere else. To make this possible the legend can be
                 detached from the chart. Detaching means that the chart doesn't draw the legend or try to
                 change its layout. Detached legend can then be drawn wherever the user wishes, for example,
                 in a different graphics scene. The behavior of the legend can be inspected by running the
                 legend example.
                 In the example we use the bar series where we add or remove the bar sets. The legend reflects
                 the changes in series. The legend can be detached or attached back to the chart and its
                 alignment can be modified.
                 When the legend is detached, it can be resized and positioned freely.
-                \table
+                \image examples_legend_detach.png
-                    \row
+                \image examples_legend_detach2.png
-                        \li \inlineimage examples_legend_detach.png
-                        \li \inlineimage examples_legend_detach2.png
-                \endtable
                 Here we turn the legend visible and set its alignment to the bottom of the chart.
                 \snippet legend/mainwidget.cpp 1
                 This snippet shows how to detach the legend from the chart. After detaching, we turn its background to visible and set a different color to it. This makes it easier to see how the items inside the legend are arranged in detached mode.
                 \snippet legend/mainwidget.cpp 2
                 Here we attach the legend back to the chart. The background is turned invisible.
                 \snippet legend/mainwidget.cpp 3
                 This shows how we set the detached legend dimensions. After setting the new values, we call update to show changes on screen.
                 \snippet legend/mainwidget.cpp 4
             */

src/charts/doc/src/examples-nesteddonuts.qdoc +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                  \example nesteddonuts
-                 \title Nested donuts example
+                 \title Nested Donuts Example
                  \ingroup qtcharts_examples
                  \brief This example shows how to create a nested donuts chart using the QPieSeries API.
                  \image examples_nesteddonuts.png
                  Let's start by creating a QChartView instance and enabling the Antialiasing on it. A QChart object is then obtained from the QChartView instance.
                  The legend is disabled and the title of the chart is set. Last line enables the animations of the chart.
                  \snippet nesteddonuts/widget.cpp 1
                  Three variables are defined that will be used to define the donut chart. Min and max size define the relative size of the whole donut.
                  minSize is the relative inner size of the smallest donut. maxSize is the relative outer size of the biggest donut.
                  \snippet nesteddonuts/widget.cpp 2
                  The following block of code defines the individual donuts and their slices. First a new QPieSeries object is created.
                  The number of slices in each donut is randomized.
                  The internal for loop creates the slices with a random value and label same as the value.
                  Next the label of the slice is set to be visible and its color is set to white.
                  To make the example more interesting the hovered signal of the slice is connected to widget's slot,  of which the inner workings are explained later.
                  Finally the slice is added to the donut. The donut's size is adjusted to achieve the nesting of the donuts.
                  Then the donut is added to the widget's list of donuts and to the chart.
                  \snippet nesteddonuts/widget.cpp 3
                  Finally the widget is placed in a layout used by the application.
                  \snippet nesteddonuts/widget.cpp 4
                  To make the example more interesting the donuts are rotated randomly every 1.25 sec.
                  \snippet nesteddonuts/widget.cpp 5
                  The widget's updatedRotation slot is defined below.
                  It goes through all of the donuts and modifies their current rotation by a random value.
                  \snippet nesteddonuts/widget.cpp 6
                  The earlier mentioned explodeSlice slot code is provided below.
                  If the slice is set to exploded, then stop the timer that controls the donuts rotation.
                  Then the slice's start and end angles are obtained from the slice.
                  To highlight the selected slice all the other donuts that lie outward from the one that contains the selected slice
                  have their start and end angles modified so that they wouldn't "block" the way for the hightlighted slice.
                  If the slice is no longer selected return to the original state.
                  \snippet nesteddonuts/widget.cpp 7
             */

src/charts/doc/src/examples-piechartcustomization.qdoc +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                 \example piechartcustomization
-                \title Pie chart customization example
+                \title Pie Chart Customization Example
                 \ingroup qtcharts_examples
                 \brief This example shows how the look and feel of a pie chart can be customized.
                 \image piechart_customization.png
             */

src/charts/doc/src/examples-qmlaxes.qdoc +15 -24

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                 \example qmlaxes
                 \title Qml Axes
                 \ingroup qtcharts_examples
                 \brief This is a demonstration of how to use axes in your QML application.
-                \table
+                We begin with a chart that has a line series and a scatter series with random
-                    \row
+                data. Both series use the same axes.
-                        \li \br
-                            We begin with a chart that has a line series and a scatter series with random
+                \image examples_qmlaxes1.png
-                            data. Both series use the same axes.
+                \snippet qmlaxes/qml/qmlaxes/View1.qml 1
-                            \br
-                            \br
+                The next example shows a chart with some accurate historical data that makes us to use a DateTimeAxis.
-                            \snippet qmlaxes/qml/qmlaxes/View1.qml 1
-                        \li \inlineimage examples_qmlaxes1.png
+                \image examples_qmlaxes2.png
-                    \row
+                \snippet qmlaxes/qml/qmlaxes/View2.qml 1
-                        \li \br
-                            The next example shows a chart with some accurate historical data that makes us to use a DateTimeAxis.
+                And the final example with a chart that uses a CategoryAxis to make the data easier to understand.
-                            \br
-                            \br
+                \image examples_qmlaxes3.png
-                            \snippet qmlaxes/qml/qmlaxes/View2.qml 1
+                \snippet qmlaxes/qml/qmlaxes/View3.qml 1
-                        \li \inlineimage examples_qmlaxes2.png
-                    \row
-                        \li  \br
-                            And the final example with a chart that uses a CategoryAxis to make the data easier to understand.
-                            \br
-                            \br
-                            \snippet qmlaxes/qml/qmlaxes/View3.qml 1
-                        \li \inlineimage examples_qmlaxes3.png
-                \endtable
             */

src/charts/doc/src/examples-qmlchart.qdoc +51 -112

@@ -1,143 +1,82
1	/****************************************************************************	1	/****************************************************************************
2	**	2	**
3	** Copyright (C) 2014 Digia Plc	3	** Copyright (C) 2014 Digia Plc
4	** All rights reserved.	4	** All rights reserved.
5	** For any questions to Digia, please use contact form at http://qt.io	5	** For any questions to Digia, please use contact form at http://qt.io
6	**	6	**
7	** This file is part of the Qt Charts module.	7	** This file is part of the Qt Charts module.
8	**	8	**
9	** Licensees holding valid commercial license for Qt may use this file in	9	** Licensees holding valid commercial license for Qt may use this file in
10	** accordance with the Qt License Agreement provided with the Software	10	** accordance with the Qt License Agreement provided with the Software
11	** or, alternatively, in accordance with the terms contained in a written	11	** or, alternatively, in accordance with the terms contained in a written
12	** agreement between you and Digia.	12	** agreement between you and Digia.
13	**	13	**
14	** If you have questions regarding the use of this file, please use	14	** If you have questions regarding the use of this file, please use
15	** contact form at http://qt.io	15	** contact form at http://qt.io
16	**	16	**
17	****************************************************************************/	17	****************************************************************************/
18		18
19	/*!	19	/*!
20	\example qmlchart	20	\example qmlchart
21	\title Qml ~~charts e~~xample	21	\title Qml Charts Example
22	\ingroup qtcharts_examples	22	\ingroup qtcharts_examples
23		23
24	\brief This basic demonstration shows how to use the different chart types by using qml.	24	\brief This basic demonstration shows how to use the different chart types by using qml.
25		25
26	Creating each chart type begins with the creation of a ChartView.	26	Creating each chart type begins with the creation of a ChartView.
27		27
28	\table	28	To create a pie, we use the PieSeries API together with a few PieSlices:
29	\row	29
30	\li \br	30	\image examples_qmlchart1.png
31	To create a pie, we use the PieSeries API together with a few PieSlices:	31	\snippet qmlchart/qml/qmlchart/View1.qml 1
32	\br	32
33	\br	33	To create a chart with a line series:
34	\snippet qmlchart/qml/qmlchart/View1.qml 1	34
35	\~~li \inline~~image examples_qmlchart1.png	35	\image examples_qmlchart2.png
36	\endtable	36	\snippet qmlchart/qml/qmlchart/View2.qml 1
37		37
38	\table	38	And spline series:
39	\row	39
40	\li \br	40	\image examples_qmlchart3.png
41	To create a chart with a line series:	41	\snippet qmlchart/qml/qmlchart/View3.qml 1
42	\br	42
43	\br	43	Then we create a chart that illustrates the NHL All-Star player selections by using
44	\snippet qmlchart/qml/qmlchart/View2.qml 1	44	three area series:
45	\li \inlineimage examples_qmlchart2.png	45
46	\endtable	46	\image examples_qmlchart4.png
47		47	\snippet qmlchart/qml/qmlchart/View4.qml 1
48	\~~table~~	48	\dots
49	\row	49
50	\li \br	50	Then a couple of scatter series:
51	And spline series:	51
52	\br	52	\image examples_qmlchart5.png
53	\br	53	\snippet qmlchart/qml/qmlchart/View5.qml 1
54	\snippet qmlchart/qml/qmlchart/View3.qml 1	54	\dots
55	\li \inlineimage examples_qmlchart3.png
56	\endtable
57
58	\table
59	\row
60	\li \br
61	Then we create a chart that illustrates the NHL All-Star player selections by using
62	three area series:
63	\br
64	\br
65	\snippet qmlchart/qml/qmlchart/View4.qml 1
66	\dots
67	\li \inlineimage examples_qmlchart4.png
68	\endtable
69
70	\table
71	\row
72	\li \br
73	Then a couple of scatter series:
74	\br
75	\br
76	\snippet qmlchart/qml/qmlchart/View5.qml 1
77	\dots
78	\li \inlineimage examples_qmlchart5.png
79	\endtable
80		55
81	And a few different bar series:	56	And a few different bar series:
82	\table	57
83	\row	58	\image examples_qmlchart6.png
84	\li \br	59	\snippet qmlchart/qml/qmlchart/View6.qml 1
85	\br	60
86	\br	61	\image examples_qmlchart7.png
87	\snippet qmlchart/qml/qmlchart/View6.qml 1	62	\snippet qmlchart/qml/qmlchart/View7.qml 1
88	\li \inlineimage examples_qmlchart6.png	63
89	\endtable	64	\image examples_qmlchart8.png
90	\table	65	\snippet qmlchart/qml/qmlchart/View8.qml 1
91	\row	66
92	\li \br	67	\image examples_qmlchart9.png
93	\br	68	\snippet qmlchart/qml/qmlchart/View9.qml 1
94	\br	69
95	\snippet qmlchart/qml/qmlchart/View7.qml 1	70	\image examples_qmlchart10.png
96	\li \inlineimage examples_qmlchart7.png	71	\snippet qmlchart/qml/qmlchart/View10.qml 1
97	\endtable	72
98	\table	73	\image examples_qmlchart11.png
99	\row	74	\snippet qmlchart/qml/qmlchart/View11.qml 1
100	\li \br	75
101	\br	76	And finally an example demonstrating how to create a donut chart with two pie series:
102	\br	77
103	\snippet qmlchart/qml/qmlchart/View8.qml 1	78	\image examples_qmlchart12.png
104	\li \inlineimage examples_qmlchart8.png	79	\snippet qmlchart/qml/qmlchart/View12.qml 1
105	\endtable
106	\table
107	\row
108	\li \br
109	\br
110	\br
111	\snippet qmlchart/qml/qmlchart/View9.qml 1
112	\li \inlineimage examples_qmlchart9.png
113	\endtable
114	\table
115	\row
116	\li \br
117	\br
118	\br
119	\snippet qmlchart/qml/qmlchart/View10.qml 1
120	\li \inlineimage examples_qmlchart10.png
121	\endtable
122	\table
123	\row
124	\li \br
125	\br
126	\br
127	\snippet qmlchart/qml/qmlchart/View11.qml 1
128	\li \inlineimage examples_qmlchart11.png
129	\endtable
130
131	\table
132	\row
133	\li \br
134	And finally an example demonstrating how to create a donut chart with two pie
135	series:
136	\br
137	\br
138	\snippet qmlchart/qml/qmlchart/View12.qml 1
139	\li \inlineimage examples_qmlchart12.png
140	\endtable
141		80
142	Additionally, antialiasing is set with the qml property in Qt Quick 2.	81	Additionally, antialiasing is set with the qml property in Qt Quick 2.
143	*/	82	*/

src/charts/doc/src/examples-qmlcustomlegend.qdoc +20 -32

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                 \example qmlcustomlegend
                 \title Qml Custom Legend
                 \ingroup qtcharts_examples
                 \brief This example shows you how to create your own custom legend.
                 This application shows you how to create your own custom legend instead of using the
                 built-in legend of ChartView API.
-                \table
+                The main view of the application shows a stacked area chart. This is how one of
-                    \row
+                the stacked areas is created. See ChartViewStacked.qml and AnimatedAreaSeries.qml.
-                        \li \br
-                            The main view of the application shows a stacked area chart. This is how one of
+                \image examples_qmlcustomlegend1.png
-                            \br
+                \snippet qmlcustomlegend/qml/qmlcustomlegend/ChartViewStacked.qml 1
-                            the stacked areas is created. See ChartViewStacked.qml and AnimatedAreaSeries.qml.
-                            \br
+                Hovering with mouse on top of the legend will highlight the hovered series.
-                            \br
+                (see CustomLegend.qml).
-                            \snippet qmlcustomlegend/qml/qmlcustomlegend/ChartViewStacked.qml 1
-                        \li \inlineimage examples_qmlcustomlegend1.png
+                \image examples_qmlcustomlegend2.png
-                    \row
+                \snippet qmlcustomlegend/qml/qmlcustomlegend/CustomLegend.qml 1
-                        \li \br
+                \snippet qmlcustomlegend/qml/qmlcustomlegend/CustomLegend.qml 2
-                            Hovering with mouse on top of the legend will highlight the hovered series.
+                \dots
-                            \br
+                \snippet qmlcustomlegend/qml/qmlcustomlegend/CustomLegend.qml 3
-                            (see CustomLegend.qml).
-                            \br
+                You can also select one of the stacked areas for a closer look as a line series by
-                            \br
+                a mouse click (see ChartViewHighlighted.qml).
-                            \snippet qmlcustomlegend/qml/qmlcustomlegend/CustomLegend.qml 1
-                            \snippet qmlcustomlegend/qml/qmlcustomlegend/CustomLegend.qml 2
+                \image examples_qmlcustomlegend3.png
-                            \dots
+                \snippet qmlcustomlegend/qml/qmlcustomlegend/ChartViewHighlighted.qml 1
-                            \snippet qmlcustomlegend/qml/qmlcustomlegend/CustomLegend.qml 3
-                        \li \inlineimage examples_qmlcustomlegend2.png
-                    \row
-                        \li \br
-                            You can also select one of the stacked areas for a closer look as a line series by
-                            \br
-                            a mouse click (see ChartViewHighlighted.qml).
-                            \br
-                            \br
-                            \snippet qmlcustomlegend/qml/qmlcustomlegend/ChartViewHighlighted.qml 1
-                        \li \inlineimage examples_qmlcustomlegend3.png
-                \endtable
             */

src/charts/doc/src/examples-qmlpolarchart.qdoc +17 -27

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                 \example qmlpolarchart
                 \title Qml Polar Chart
                 \ingroup qtcharts_examples
                 \brief This is a demonstration on how to use a polar chart in your QML application.
-                \table
+                We begin with a chart that has a spline series and a scatter series with random
-                    \row
+                data. Both series use the same axes.
-                        \li \br
-                            We begin with a chart that has a spline series and a scatter series with random
+                \image examples_qmlpolarchart1.png
-                            data. Both series use the same axes.
+                \snippet qmlpolarchart/qml/qmlpolarchart/View1.qml 1
-                            \br
-                            \br
+                The next example shows a chart with some accurate historical data for which we need
-                            \snippet qmlpolarchart/qml/qmlpolarchart/View1.qml 1
+                to use a DateTimeAxis and a AreaSeries.
-                        \li \inlineimage examples_qmlpolarchart1.png
-                    \row
+                \image examples_qmlpolarchart2.png
-                        \li \br
+                \snippet qmlpolarchart/qml/qmlpolarchart/View2.qml 1
-                            The next example shows a chart with some accurate historical data for which we need
-                            to use a DateTimeAxis
+                And the final example with a chart that uses a CategoryAxis to make the data easier
-                            and a AreaSeries.
+                to understand.
-                            \br
-                            \br
+                \image examples_qmlpolarchart3.png
-                            \snippet qmlpolarchart/qml/qmlpolarchart/View2.qml 1
+                \snippet qmlpolarchart/qml/qmlpolarchart/View3.qml 1
-                        \li \inlineimage examples_qmlpolarchart2.png
-                    \row
-                        \li \br
-                            And the final example with a chart that uses a CategoryAxis to make the data easier
-                            to understand.
-                            \br
-                            \br
-                            \snippet qmlpolarchart/qml/qmlpolarchart/View3.qml 1
-                        \li \inlineimage examples_qmlpolarchart3.png
-                \endtable
             */

src/charts/doc/src/examples-scatterinteractions.qdoc +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                  \example scatterinteractions
-                 \title ScatterInteractions Example
+                 \title Scatter Interactions Example
                  \ingroup qtcharts_examples
                  \brief This example shows how to create a simple scatter chart and how to interact with the
                 chart.
                  \image examples_scatterinteractions.png
             */

src/charts/doc/src/examples-temperaturerecords.qdoc +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                 \example temperaturerecords
-                \title Temperature records example
+                \title Temperature Records Example
                 \ingroup qtcharts_examples
                 \brief The example shows how to create a bar chart with negative bars.
                 For our example we use temperature data.
                 \image examples_temperaturerecords.png
                 First we create two barsets and append the data to them. One set represents the minimum temperatures and another the maximum temperatures.
                 \snippet temperaturerecords/main.cpp 1
                 We create the series and append the barsets to it. The series takes ownership of the barsets.
                 \snippet temperaturerecords/main.cpp 2
                 Here we create the chart object and add the series to it. We set the title for the chart with setTitle, and then turn on animations of the series by calling
                 setAnimationOptions(QChart::SeriesAnimations)
                 \snippet temperaturerecords/main.cpp 3
                 To have categories displayed on an axis, we need to create a QBarCategoryAxis. Here we create a category axis with a list of categories and
                 set it to be the x-axis of the chart. The chart takes ownership of the axis. For y-axis we use the default axis, which is created and scaled to the series data
                 by calling createDefaultAxes of the chart. We change the range for the y-axis, since this gives nicer result than with autoscaling.
                 Note that the call for createDefaultAxes must be before we set the category axis. Otherwise the default axis will override the category axis.
                 \snippet temperaturerecords/main.cpp 4
                 We also want to show the legend. To do so, we get the legend pointer from the chart and set it to visible. We also place the legend to the bottom
                 of the chart by setting its alignment to Qt::AlignBottom.
                 \snippet temperaturerecords/main.cpp 5
                 Finally we add the chart onto a view. We also turn on the antialiasing for the chartView.
                 \snippet temperaturerecords/main.cpp 6
                 Chart is ready to be shown. We set the chart to be the central widget of the window.
                 We also set the size for the chart window and show it.
                 \snippet temperaturerecords/main.cpp 7
             */

src/charts/doc/src/index.qdoc +1 -2

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                 \title Qt Charts
                 \page index.html
                 \keyword About
-                Qt Charts is a part of the Qt Enterprise addons package. It provides a set of easy to use chart
+                Qt Charts module provides a set of easy to use chart components. It uses the Qt Graphics View
-                components which are available for Qt customers. It uses the Qt Graphics View
                 Framework, therefore charts can be easily integrated to modern user interfaces. Qt Charts can
                 be used as QWidgets, QGraphicsWidget, or QML types. Users can easily create impressive
                 graphs by selecting one of the charts themes.
                 \section1 Getting Started
                 To import Qt Charts QML types, add the following import statement to your \c .qml file:
                 \snippet doc_src_qmlcharts.cpp 0
                 If you intend to use Qt Charts C++ classes in your application, use the
                 following include and using directives:
                 \snippet doc_src_qtcharts.cpp 0
                 \note If you are only using a few classes from this module, we recommend including only those
                 specific classes instead of the whole module.
                 To link against the Qt Charts module, add this line to your \c qmake project file:
                 \snippet doc_src_qtcharts.pro 0
                 See the \l{Qt Charts Getting Started}{Getting started} page for further information on
                 how to use Qt Charts in your application.
                 \section1 References
                 \list
                     \li \l{Qt Charts C++ Classes}
                     \li \l{Qt Charts QML Types}
                 \endlist
                 Qt Charts comes with the following examples:
                 \annotatedlist qtcharts_examples
             */

src/charts/doc/src/qtcharts.qdoc +5 -11

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             /*!
                 \module Qt Charts
                 \title Qt Charts C++ Classes
                 \ingroup modules
                 \brief C++ classes for the Qt Charts API.
                 Charts API is built on top of Qt Graphics View Framework. Charts can be displayed as QGraphicsWidget using the QChart class. However
                 there is also the convenience class QChartView, which is QWidget based. These enable us to quickly use Qt Charts as a normal Qt widget.
                 Each chart type is represented by the QAbstractSeries derived class. To create charts, the users have to use an instance of the related
                 series class and add it to a QChart instance.
                 \code
                 QLineSeries* series = new QLineSeries();
                 series->add(0, 6);
                 series->add(2, 4);
                 ...
                 chartView->chart()->addSeries(series);
                 chartView->chart()->createDefaultAxes();
                 \endcode
             */
             /*!
                 \qmlmodule QtCharts 2.0
                 \title Qt Charts QML Types
                 \ingroup qmlmodules
                 \brief QML types for the Qt Charts API.
                 The Qt Charts QML API is an intuitive and simple way to show charts in your QML
                 applications.
-                \table
+                Use the following QML to create a simple pie chart:
-                    \row
+                \image examples_qmlpiechart.png
-                        \li \br
+                \snippet qmlpiechart/qml/qmlpiechart/main.qml 1
-                            Use the following QML to create a simple pie chart:
+                \snippet qmlpiechart/qml/qmlpiechart/main.qml 2
-                            \br
+                \snippet qmlpiechart/qml/qmlpiechart/main.qml 3
-                            \br
-                            \snippet qmlpiechart/qml/qmlpiechart/main.qml 1
-                            \snippet qmlpiechart/qml/qmlpiechart/main.qml 2
-                            \snippet qmlpiechart/qml/qmlpiechart/main.qml 3
-                        \li \inlineimage examples_qmlpiechart.png
-                \endtable
                 \note Since Qt Creator 3.0 the project created with Qt Quick Application wizard based on
                 Qt Quick 2 template uses QGuiApplication by default. As Qt Charts utilizes Qt Graphics View
                 Framework for drawing, QApplication must be used. The project created with the wizard is
                 usable with Qt Charts after the QGuiApplication is replaced with QApplication.
                 \section1 QML Types
             */
             /*!
                 \group charts_examples
                 \ingroup all-examples
                 \title Qt Charts Examples
                 \brief Examples for the Qt Charts.
                 For some code examples, see one of the Qt Charts examples:
                 \section1 Examples
                 \annotatedlist qtcharts_examples
             */
             /*!
                 \group qtcharts_getting_started
                 \title Qt Charts Getting Started
                 \section1 Installing the Qt Charts module
                 Use the \c {Package Manager} in \c {Maintenance Tool} or the \c {Online installer} to install
                 the Qt Charts module. The module can be found under \c {Qt Enterprise Add-Ons} in the
                 package manager.
                 After installation Qt Charts documentation and examples are available in Qt Creator.
                 Examples can be found on the examples page of Qt Creator by selecting the Qt Charts
                 component from the drop-down menu.
                 The source code is installed into the QtCharts folder under EnterpriseAddOns.
                 \section1 Building Qt Charts
                 To build the Qt Charts module from source code yourself, set up a command prompt with
                 an environment for building Qt applications, navigate to the directory containing
                 \c {qtcharts.pro}, and configure the project with qmake:
                 \code
                 qmake
                 \endcode
                 After running qmake, build the project with make:
                 \table
                 \header
                   \li OS                       \li Make command
                 \row
                   \li Linux                    \li make
                 \row
                   \li Windows (MinGw)          \li mingw32-make
                 \row
                   \li Windows (MSVC)           \li nmake
                 \row
                   \li OSX                      \li make
                 \endtable
                 The above generates the default makefiles for your configuration, which is typically
                 the release build if you are using precompiled binary Qt distribution. To build both debug
                 and release, or one specifically, use one of the following qmake lines instead.
                 For debug builds:
                 \code
                 qmake CONFIG+=debug
                 make
                 \endcode
                 or
                 \code
                 qmake CONFIG+=debug_and_release
                 make debug
                 \endcode
                 For release builds:
                 \code
                 qmake CONFIG+=release
                 make
                 \endcode
                 or
                 \code
                 qmake CONFIG+=debug_and_release
                 make release
                 \endcode
                 For both builds (Windows/OS X only):
                 \code
                 qmake CONFIG+="debug_and_release build_all"
                 make
                 \endcode
                 After building, install the module to your Qt directory:
                 \code
                 make install
                 \endcode
                 If you want to uninstall the module:
                 \code
                 make uninstall
                 \endcode
                 To build a statically linked version of the Qt Charts module, give the following commands:
                 \snippet doc_src_qtcharts.cpp 1
                 \section1 Running examples
                 Qt Charts examples are found under the \c examples subdirectory. To build and run a single
                 example, in this case qmlpolarchart, navigate to the example directory and enter the following
                 commands:
                 \snippet doc_src_qtcharts.cpp 2
                 \note On some platforms, such as Windows, the executable can be generated under debug or
                 release folders, depending on your build.
                 \section1 Creating a simple application
                 To create a simple application, start by creating a new Qt Gui Application project in Qt
                 Creator and add this line to the \c .pro file of the project:
                 \snippet doc_src_qtcharts.pro 0
                 In the \c main.cpp file, include the module headers and declare namespace usage:
                 \snippet doc_src_qtcharts.cpp 0
                 \note Since Qt Creator 3.0 the project created with Qt Quick Application wizard based on
                 Qt Quick 2 template uses QGuiApplication by default. As Qt Charts utilizes Qt Graphics View
                 Framework for drawing, QApplication must be used. The project created with the wizard is
                 usable with Qt Charts after the QGuiApplication is replaced with QApplication.
                 For further code examples, see one of the Qt Charts examples:
                 \annotatedlist qtcharts_examples
             */

src/charts/piechart/qpieseries.cpp +2 -5

             /****************************************************************************
             **
             ** Copyright (C) 2014 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt 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.io
             **
             ****************************************************************************/
             #include <QtCharts/QPieSeries>
             #include <private/qpieseries_p.h>
             #include <QtCharts/QPieSlice>
             #include <private/qpieslice_p.h>
             #include <private/pieslicedata_p.h>
             #include <private/chartdataset_p.h>
             #include <private/charttheme_p.h>
             #include <QtCharts/QAbstractAxis>
             #include <private/pieanimation_p.h>
             #include <private/charthelpers_p.h>
             #include <QtCharts/QPieLegendMarker>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries
                 \inmodule Qt Charts
                 \brief Pie series API for Qt Charts.
                 The pie series defines a pie chart which consists of pie slices which are defined as QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 Pie size and position on the chart is controlled by using relative values which range from 0.0 to 1.0.
                 These relate to the actual chart rectangle.
                 By default the pie is defined as a full pie but it can also be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 Full pie is 360 degrees where 0 is at 12 a'clock.
                 See the \l {PieChart Example} {pie chart example} or \l {DonutChart Example} {donut chart example} to learn how to use QPieSeries.
-                \table 100%
+                \image examples_piechart.png
-                \row
+                \image examples_donutchart.png
-                \li \image examples_piechart.png
-                \li \image examples_donutchart.png
-                \endtable
             */
             /*!
                 \qmltype PieSeries
                 \instantiates QPieSeries
                 \inqmlmodule QtCharts
                 \inherits AbstractSeries
                 \brief The PieSeries type is used for making pie charts.
                 The following QML shows how to create a simple pie chart.
                 \snippet qmlchart/qml/qmlchart/View1.qml 1
                 \beginfloatleft
                 \image examples_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
                 \li 0.0 is the absolute left.
                 \li 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
                 \li 0.0 is the absolute left.
                 \li 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
                 \li 0.0 is the absolute top.
                 \li 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
                 \li 0.0 is the absolute top.
                 \li 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
                 \li 0.0 is the minimum size (pie not drawn).
                 \li 1.0 is the maximum size that can fit the chart.
                 \endlist
                 When setting this property the holeSize property is adjusted if necessary, to ensure that the hole size is not greater than the outer size.
                 Default value is 0.7.
             */
             /*!
                 \qmlproperty real PieSeries::size
                 Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \li 0.0 is the minimum size (pie not drawn).
                 \li 1.0 is the maximum size that can fit the chart.
                 \endlist
                 Default value is 0.7.
             */
             /*!
                 \property QPieSeries::holeSize
                 \brief Defines the donut hole size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \li 0.0 is the minimum size (full pie drawn, without any hole inside).
                 \li 1.0 is the maximum size that can fit the chart. (donut has no width)
                 \endlist
                 The value is never greater then size property.
                 Default value is 0.0.
             */
             /*!
                 \qmlproperty real PieSeries::holeSize
                 Defines the donut hole size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \li 0.0 is the minimum size (full pie drawn, without any hole inside).
                 \li 1.0 is the maximum size that can fit the chart. (donut has no width)
                 \endlist
                 When setting this property the size property is adjusted if necessary, to ensure that the inner size is not greater than the outer size.
                 Default value is 0.0.
             */
             /*!
                 \property QPieSeries::startAngle
                 \brief Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \qmlproperty real PieSeries::startAngle
                 Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \property QPieSeries::endAngle
                 \brief Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 \qmlproperty real PieSeries::endAngle
                 Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 \property QPieSeries::count
                 Number of slices in the series.
             */
             /*!
                 \qmlproperty int PieSeries::count
                 Number of slices in the series.
             */
             /*!
                 \fn void QPieSeries::countChanged()
                 Emitted when the slice count has changed.
                 \sa count
             */
             /*!
                 \qmlsignal PieSeries::onCountChanged()
                 Emitted when the slice count has changed.
             */
             /*!
                 \property QPieSeries::sum
                 Sum of all slices.
                 The series keeps track of the sum of all slices it holds.
             */
             /*!
                 \qmlproperty real PieSeries::sum
                 Sum of all slices.
                 The series keeps track of the sum of all slices it holds.
             */
             /*!
                 \fn void QPieSeries::sumChanged()
                 Emitted when the sum of all slices has changed.
                 \sa sum
             */
             /*!
                 \qmlsignal PieSeries::onSumChanged()
                 Emitted when the sum of all slices has changed. This may happen for example if you add or remove slices, or if you
                 change value of a slice.
             */
             /*!
                 \fn void QPieSeries::added(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal PieSeries::onAdded(PieSlice slice)
                 Emitted when \a slice has been added to the series.
             */
             /*!
                 \fn void QPieSeries::removed(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been removed from the series.
                 \sa remove()
             */
             /*!
                 \qmlsignal PieSeries::onRemoved(PieSlice slice)
                 Emitted when \a slice has been removed from the series.
             */
             /*!
                 \fn void QPieSeries::clicked(QPieSlice *slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
               \qmlsignal PieSeries::onClicked(PieSlice slice)
               This signal is emitted when a \a slice has been clicked.
             */
             /*!
                 \fn void QPieSeries::pressed(QPieSlice *slice)
                 This signal is emitted when a \a slice has been pressed.
                 \sa QPieSlice::pressed()
             */
             /*!
                 \qmlsignal PieSeries::onPressed(PieSlice slice)
                 This signal is emitted when a \a slice has been pressed.
             */
             /*!
                 \fn void QPieSeries::released(QPieSlice *slice)
                 This signal is emitted when a \a slice has been released.
                 \sa QPieSlice::released()
             */
             /*!
                 \qmlsignal PieSeries::onReleased(PieSlice slice)
                 This signal is emitted when a \a slice has been released.
             */
             /*!
                 \fn void QPieSeries::doubleClicked(QPieSlice *slice)
                 This signal is emitted when a \a slice has been doubleClicked.
                 \sa QPieSlice::doubleClicked()
             */
             /*!
                 \qmlsignal PieSeries::onDoubleClicked(PieSlice slice)
                 This signal is emitted when a \a slice has been doubleClicked.
             */
             /*!
                 \fn void QPieSeries::hovered(QPieSlice* slice, bool state)
                 This signal is emitted when user has hovered over or away from the \a slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
                 \sa QPieSlice::hovered()
             */
             /*!
                 \qmlsignal PieSeries::onHovered(PieSlice slice, bool state)
                 This signal is emitted when user has hovered over or away from the \a slice. \a state is true when user has hovered
                 over the slice and false when hover has moved away from the slice.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::at(int index)
                 Returns slice at \a index. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::find(string label)
                 Returns the first slice with \a label. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::append(string label, real value)
                 Adds a new slice with \a label and \a value to the pie.
             */
             /*!
                 \qmlmethod bool PieSeries::remove(PieSlice slice)
                 Removes the \a slice from the pie. Returns true if the removal was successful, false otherwise.
             */
             /*!
                 \qmlmethod PieSeries::clear()
                 Removes all slices from the pie.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent)
                 : QAbstractSeries(*new QPieSeriesPrivate(this), parent)
             {
                 Q_D(QPieSeries);
                 QObject::connect(this, SIGNAL(countChanged()), d, SIGNAL(countChanged()));
             }
             /*!
                 Destroys the series and its slices.
             */
             QPieSeries::~QPieSeries()
             {
                 // NOTE: d_prt destroyed by QObject
                 clear();
             }
             /*!
                 Returns QAbstractSeries::SeriesTypePie.
             */
             QAbstractSeries::SeriesType QPieSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePie;
             }
             /*!
                 Appends a single \a slice to the series.
                 Slice ownership is passed to the series.
                 Returns true if append was succesfull.
             */
             bool QPieSeries::append(QPieSlice *slice)
             {
                 return append(QList<QPieSlice *>() << slice);
             }
             /*!
                 Appends an array of \a slices to the series.
                 Slice ownership is passed to the series.
                 Returns true if append was successful.
             */
             bool QPieSeries::append(QList<QPieSlice *> slices)
             {
                 Q_D(QPieSeries);
                 if (slices.count() == 0)
                     return false;
                 foreach (QPieSlice *s, slices) {
                     if (!s || d->m_slices.contains(s))
                         return false;
                     if (s->series()) // already added to some series
                         return false;
                     if (!isValidValue(s->value()))
                         return false;
                 }
                 foreach (QPieSlice *s, slices) {
                     s->setParent(this);
                     QPieSlicePrivate::fromSlice(s)->m_series = this;
                     d->m_slices << s;
                 }
                 d->updateDerivativeData();
                 foreach(QPieSlice * s, slices) {
                     connect(s, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                     connect(s, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                     connect(s, SIGNAL(pressed()), d, SLOT(slicePressed()));
                     connect(s, SIGNAL(released()), d, SLOT(sliceReleased()));
                     connect(s, SIGNAL(doubleClicked()), d, SLOT(sliceDoubleClicked()));
                 }
                 emit added(slices);
                 emit countChanged();
                 return true;
             }
             /*!
                 Appends a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries &QPieSeries::operator << (QPieSlice *slice)
             {
                 append(slice);
                 return *this;
             }
             /*!
                 Appends a single slice to the series with give \a value and \a label.
                 Slice ownership is passed to the series.
                 Returns NULL if value is NaN, Inf or -Inf and no slice is added to the series.
             */
             QPieSlice *QPieSeries::append(QString label, qreal value)
             {
                 if (isValidValue(value)) {
                     QPieSlice *slice = new QPieSlice(label, value);
                     append(slice);
                     return slice;
                 } else {
                     return 0;
                 }
             }
             /*!
                 Inserts a single \a slice to the series before the slice at \a index position.
                 Slice ownership is passed to the series.
                 Returns true if insert was successful.
             */
             bool QPieSeries::insert(int index, QPieSlice *slice)
             {
                 Q_D(QPieSeries);
                 if (index < 0 || index > d->m_slices.count())
                     return false;
                 if (!slice || d->m_slices.contains(slice))
                     return false;
                 if (slice->series()) // already added to some series
                     return false;
                 if (!isValidValue(slice->value()))
                     return false;
                 slice->setParent(this);
                 QPieSlicePrivate::fromSlice(slice)->m_series = this;
                 d->m_slices.insert(index, slice);
                 d->updateDerivativeData();
                 connect(slice, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                 connect(slice, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                 connect(slice, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 connect(slice, SIGNAL(pressed()), d, SLOT(slicePressed()));
                 connect(slice, SIGNAL(released()), d, SLOT(sliceReleased()));
                 connect(slice, SIGNAL(doubleClicked()), d, SLOT(sliceDoubleClicked()));
                 emit added(QList<QPieSlice *>() << slice);
                 emit countChanged();
                 return true;
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference the pointer after this call.
                 Returns true if remove was successful.
             */
             bool QPieSeries::remove(QPieSlice *slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice))
                     return false;
                 d->updateDerivativeData();
                 emit removed(QList<QPieSlice *>() << slice);
                 emit countChanged();
                 delete slice;
                 slice = 0;
                 return true;
             }
             /*!
                 Takes a single \a slice from the series. Does not destroy the slice object.
                 \note The series remains as the slice's parent object. You must set the
                 parent object to take full ownership.
                 Returns true if take was successful.
             */
             bool QPieSeries::take(QPieSlice *slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice))
                     return false;
                 QPieSlicePrivate::fromSlice(slice)->m_series = 0;
                 slice->disconnect(d);
                 d->updateDerivativeData();
                 emit removed(QList<QPieSlice *>() << slice);
                 emit countChanged();
                 return true;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 Q_D(QPieSeries);
                 if (d->m_slices.count() == 0)
                     return;
                 QList<QPieSlice *> slices = d->m_slices;
                 foreach (QPieSlice *s, d->m_slices)
                     d->m_slices.removeOne(s);
                 d->updateDerivativeData();
                 emit removed(slices);
                 emit countChanged();
                 foreach (QPieSlice *s, slices)
                     delete s;
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice *> QPieSeries::slices() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices;
             }
             /*!
                 returns the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.count();
             }
             /*!
                 Returns true is the series is empty.
             */
             bool QPieSeries::isEmpty() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.isEmpty();
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue(), QPieSlice::percentage()
             */
             qreal QPieSeries::sum() const
             {
                 Q_D(const QPieSeries);
                 return d->m_sum;
             }
             void QPieSeries::setHoleSize(qreal holeSize)
             {
                 Q_D(QPieSeries);
                 holeSize = qBound((qreal)0.0, holeSize, (qreal)1.0);
                 d->setSizes(holeSize, qMax(d->m_pieRelativeSize, holeSize));
             }
             qreal QPieSeries::holeSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_holeRelativeSize;
             }
             void QPieSeries::setHorizontalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (relativePosition < 0.0)
                     relativePosition = 0.0;
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
                 if (!qFuzzyCompare(d->m_pieRelativeHorPos, relativePosition)) {
                     d->m_pieRelativeHorPos = relativePosition;
                     emit d->horizontalPositionChanged();
                 }
             }
             qreal QPieSeries::horizontalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeHorPos;
             }
             void QPieSeries::setVerticalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (relativePosition < 0.0)
                     relativePosition = 0.0;
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
                 if (!qFuzzyCompare(d->m_pieRelativeVerPos, relativePosition)) {
                     d->m_pieRelativeVerPos = relativePosition;
                     emit d->verticalPositionChanged();
                 }
             }
             qreal QPieSeries::verticalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeVerPos;
             }
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 Q_D(QPieSeries);
                 relativeSize = qBound((qreal)0.0, relativeSize, (qreal)1.0);
                 d->setSizes(qMin(d->m_holeRelativeSize, relativeSize), relativeSize);
             }
             qreal QPieSeries::pieSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeSize;
             }
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (qFuzzyCompare(d->m_pieStartAngle, angle))
                     return;
                 d->m_pieStartAngle = angle;
                 d->updateDerivativeData();
                 emit d->pieStartAngleChanged();
             }
             qreal QPieSeries::pieStartAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieStartAngle;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be greater than start angle.
                 \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (qFuzzyCompare(d->m_pieEndAngle, angle))
                     return;
                 d->m_pieEndAngle = angle;
                 d->updateDerivativeData();
                 emit d->pieEndAngleChanged();
             }
             /*!
                 Returns the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             qreal QPieSeries::pieEndAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 Note that this affects only the current slices in the series.
                 If user adds a new slice the default label visibility is false.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice *s, d->m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Sets the all the slice labels \a position
                 Note that this affects only the current slices in the series.
                 If user adds a new slice the default label position is LabelOutside
                 \sa QPieSlice::labelPosition(), QPieSlice::setLabelPosition()
             */
             void QPieSeries::setLabelsPosition(QPieSlice::LabelPosition position)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice *s, d->m_slices)
                     s->setLabelPosition(position);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent) :
                 QAbstractSeriesPrivate(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_sum(0),
                 m_holeRelativeSize(0.0)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
             }
             void QPieSeriesPrivate::updateDerivativeData()
             {
                 // calculate sum of all slices
                 qreal sum = 0;
                 foreach (QPieSlice *s, m_slices)
                     sum += s->value();
                 if (!qFuzzyCompare(m_sum, sum)) {
                     m_sum = sum;
                     emit q_func()->sumChanged();
                 }
                 // nothing to show..
                 if (qFuzzyCompare(m_sum, 0))
                     return;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice *> changed;
                 foreach (QPieSlice *s, m_slices) {
                     QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
                     d->setPercentage(s->value() / m_sum);
                     d->setStartAngle(sliceAngle);
                     d->setAngleSpan(pieSpan * s->percentage());
                     sliceAngle += s->angleSpan();
                 }
                 emit calculatedDataChanged();
             }
             void QPieSeriesPrivate::setSizes(qreal innerSize, qreal outerSize)
             {
                 bool changed = false;
                 if (!qFuzzyCompare(m_holeRelativeSize, innerSize)) {
                     m_holeRelativeSize = innerSize;
                     changed = true;
                 }
                 if (!qFuzzyCompare(m_pieRelativeSize, outerSize)) {
                     m_pieRelativeSize = outerSize;
                     changed = true;
                 }
                 if (changed)
                     emit pieSizeChanged();
             }
             QPieSeriesPrivate *QPieSeriesPrivate::fromSeries(QPieSeries *series)
             {
                 return series->d_func();
             }
             void QPieSeriesPrivate::sliceValueChanged()
             {
                 Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
                 updateDerivativeData();
             }
             void QPieSeriesPrivate::sliceClicked()
             {
                 QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->clicked(slice);
             }
             void QPieSeriesPrivate::sliceHovered(bool state)
             {
                 QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 if (!m_slices.isEmpty()) {
                     Q_ASSERT(m_slices.contains(slice));
                     Q_Q(QPieSeries);
                     emit q->hovered(slice, state);
                 }
             }
             void QPieSeriesPrivate::slicePressed()
             {
                 QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->pressed(slice);
             }
             void QPieSeriesPrivate::sliceReleased()
             {
                 QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->released(slice);
             }
             void QPieSeriesPrivate::sliceDoubleClicked()
             {
                 QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->doubleClicked(slice);
             }
             void QPieSeriesPrivate::initializeDomain()
             {
                 // does not apply to pie
             }
             void QPieSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QPieSeries);
                 PieChartItem *pie = new PieChartItem(q,parent);
                 m_item.reset(pie);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             void QPieSeriesPrivate::initializeAnimations(QtCharts::QChart::AnimationOptions options)
             {
                 PieChartItem *item = static_cast<PieChartItem *>(m_item.data());
                 Q_ASSERT(item);
                 if (item->animation())
                     item->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
                     item->setAnimation(new PieAnimation(item));
                 else
                     item->setAnimation(0);
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             QList<QLegendMarker*> QPieSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QPieSeries);
                 QList<QLegendMarker*> markers;
                 foreach(QPieSlice* slice, q->slices()) {
                     QPieLegendMarker* marker = new QPieLegendMarker(q,slice,legend);
                     markers << marker;
                 }
                 return markers;
             }
             void QPieSeriesPrivate::initializeAxes()
             {
             }
             QAbstractAxis::AxisType QPieSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeNoAxis;
             }
             QAbstractAxis* QPieSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return 0;
             }
             void QPieSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 //Q_Q(QPieSeries);
                 //const QList<QColor>& colors = theme->seriesColors();
                 const QList<QGradient>& gradients = theme->seriesGradients();
                 for (int i(0); i < m_slices.count(); i++) {
                     QColor penColor = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0);
                     // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                     qreal pos = (qreal)(i + 1) / (qreal) m_slices.count();
                     QColor brushColor = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), pos);
                     QPieSlice *s = m_slices.at(i);
                     QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
                     if (forced || d->m_data.m_slicePen.isThemed())
                         d->setPen(penColor, true);
                     if (forced || d->m_data.m_sliceBrush.isThemed())
                         d->setBrush(brushColor, true);
                     if (forced || d->m_data.m_labelBrush.isThemed())
                         d->setLabelBrush(theme->labelBrush().color(), true);
                     if (forced || d->m_data.m_labelFont.isThemed())
                         d->setLabelFont(theme->labelFont(), true);
                 }
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseries_p.cpp"
             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