HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2424:4543a29c8891

Fix to discard NaN, Inf and -Inf values from chart....

Mika Salmela -

r2424:4543a29c8891

parent child

Context file:

r2424:4543a29c8891

Collapse all files

src/charthelpers_p.h created 644 +26 0

@@ -0,0 +1,26
	1	#ifndef CHARTHELPERS_P_H
	2	#define CHARTHELPERS_P_H
	3
	4	#include <qnumeric.h>
	5	#include <QPointF>
	6
	7	static inline bool isValidValue(qreal value)
	8	{
	9	if (qIsNaN(value) \|\| qIsInf(value)) {
	10	qWarning("Ignored NaN, Inf, or -Inf value.");
	11	return false;
	12	}
	13	return true;
	14	}
	15
	16	static inline bool isValidValue(qreal x, qreal y)
	17	{
	18	return (isValidValue(x) && isValidValue(y));
	19	}
	20
	21	static inline bool isValidValue(const QPointF point)
	22	{
	23	return (isValidValue(point.x()) && isValidValue(point.y()));
	24	}
	25
	26	#endif // CHARTHELPERS_P_H

src/barchart/qbarset.cpp +12 -6

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qbarset.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSet
                 \brief Building block for different bar charts
                 QBarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 \mainclass
                 \sa QAbstractBarSeries, QBarSeries, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \qmlclass BarSet QBarSet
                 BarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 \sa AbstractBarSeries, BarSeries, StackedBarSeries, PercentBarSeries
             */
             /*!
                 \property QBarSet::label
                 Defines the label of the barSet.
             */
             /*!
                 \qmlproperty string BarSet::label
                 Defines the label of the barSet.
             */
             /*!
                 \property QBarSet::pen
                 \brief Defines the pen used by the barSet.
             */
             /*!
                 \property QBarSet::brush
                 \brief Defines the brush used by the barSet.
             */
             /*!
                 \property QBarSet::labelBrush
                 \brief Defines the brush used by the barSet's label.
             */
             /*!
                 \property QBarSet::labelFont
                 \brief Defines the font used by the barSet's label.
             */
             /*!
                 \qmlproperty Font BarSet::labelFont
                 Defines the font used by the barSet's label.
                 See the \l {Font} {QML Font Element} for detailed documentation.
             */
             /*!
                 \property QBarSet::color
                 The fill (brush) color of the bar set.
             */
             /*!
                 \qmlproperty color BarSet::color
                 The fill (brush) color of the bar set.
             */
             /*!
                 \property QBarSet::borderColor
                 The line (pen) color of the bar set.
             */
             /*!
                 \qmlproperty color BarSet::borderColor
                 The line (pen) color of the bar set.
             */
             /*!
                 \qmlproperty real BarSet::borderWidth
                 The width of the border line. By default the width is 2.0.
             */
             /*!
                 \property QBarSet::labelColor
                 The text (label) color of the bar set.
             */
             /*!
                 \qmlproperty color BarSet::labelColor
                 The text (label) color of the bar set.
             */
             /*!
                 \fn void QBarSet::clicked(int index)
                 The signal is emitted if the user clicks with a mouse on top of barset.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \fn void QBarSet::hovered(bool status)
                 The signal is emitted if mouse is hovered on top of barset.
                 Parameter \a status is true, if mouse entered on top of barset, false if mouse left from top of barset.
             */
             /*!
                 \fn void QBarSet::labelChanged()
                 This signal is emitted when the label of the barSet has changed.
                 \sa label
             */
             /*!
                 \qmlsignal BarSet::onLabelChanged()
                 This signal is emitted when the label of the barSet has changed.
             */
             /*!
                 \fn void QBarSet::penChanged()
                 This signal is emitted when the pen of the barSet has changed.
                 \sa pen
             */
             /*!
                 \fn void QBarSet::brushChanged()
                 This signal is emitted when the brush of the barSet has changed.
                 \sa brush
             */
             /*!
                 \fn void QBarSet::labelBrushChanged()
                 This signal is emitted when the brush of the barSet's label has changed.
                 \sa labelBrush
             */
             /*!
                 \fn void QBarSet::labelFontChanged()
                 This signal is emitted when the font of the barSet's label has changed.
                 \sa labelBrush
             */
             /*!
                 \fn void QBarSet::colorChanged(QColor)
                 This signal is emitted when the fill (brush) color of the set has changed to \a color.
             */
             /*!
                 \qmlsignal BarSet::onColorChanged(color color)
                 This signal is emitted when the fill (brush) color of the set has changed to \a color.
             */
             /*!
                 \fn void QBarSet::borderColorChanged(QColor)
                 This signal is emitted when the line (pen) color of the set has changed to \a color.
             */
             /*!
                 \qmlsignal BarSet::onBorderColorChanged(color color)
                 This signal is emitted when the line (pen) color of the set has changed to \a color.
             */
             /*!
                 \fn void QBarSet::labelColorChanged(QColor)
                 This signal is emitted when the text (label) color of the set has changed to \a color.
             */
             /*!
                 \qmlsignal BarSet::onLabelColorChanged(color color)
                 This signal is emitted when the text (label) color of the set has changed to \a color.
             */
             /*!
                 \fn void QBarSet::valuesAdded(int index, int count)
                 This signal is emitted when new values have been added to the set.
                 Parameter \a index indicates the position of the first inserted value.
                 Parameter \a count is the number of iserted values.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal BarSet::onValuesAdded(int index, int count)
                 This signal is emitted when new values have been added to the set.
                 Parameter \a index indicates the position of the first inserted value.
                 Parameter \a count is the number of iserted values.
             */
             /*!
                 \fn void QBarSet::valuesRemoved(int index, int count)
                 This signal is emitted values have been removed from the set.
                 Parameter \a index indicates the position of the first removed value.
                 Parameter \a count is the number of removed values.
                 \sa remove()
             */
             /*!
                 \qmlsignal BarSet::onValuesRemoved(int index, int count)
                 This signal is emitted values have been removed from the set.
                 Parameter \a index indicates the position of the first removed value.
                 Parameter \a count is the number of removed values.
             */
             /*!
                 \fn void QBarSet::valueChanged(int index)
                 This signal is emitted values the value in the set has been modified.
                 Parameter \a index indicates the position of the modified value.
                 \sa at()
             */
             /*!
                 \qmlsignal BarSet::onValueChanged(int index)
                 This signal is emitted values the value in the set has been modified.
                 Parameter \a index indicates the position of the modified value.
             */
             /*!
                 \qmlproperty int BarSet::count
                 The count of values on the barset
             */
             /*!
                 \qmlproperty QVariantList BarSet::values
                 The values of the barset. You can set either a list of reals or a list of points as values. If you set a list of
                 reals as values, the values are automatically completed to points by using the index of a value as it's
                 x-coordinate. For example:
                 \code
                     myBarSet1.values = [0, 5, 1, 5];
                     myBarSet2.values = [Qt.point(0, 1), Qt.point(1, 5), Qt.point(2.2, 4.3)];
                 \endcode
             */
             /*!
                 Constructs QBarSet with a label of \a label and with parent of \a parent
             */
             QBarSet::QBarSet(const QString label, QObject *parent)
                 : QObject(parent),
                   d_ptr(new QBarSetPrivate(label, this))
             {
             }
             /*!
                 Destroys the barset
             */
             QBarSet::~QBarSet()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
                 Sets new \a label for set.
             */
             void QBarSet::setLabel(const QString label)
             {
                 d_ptr->m_label = label;
                 emit labelChanged();
             }
             /*!
                 Returns label of the set.
             */
             QString QBarSet::label() const
             {
                 return d_ptr->m_label;
             }
             /*!
                 Appends new value \a value to the end of set.
             */
             void QBarSet::append(const qreal value)
             {
                 // Convert to QPointF
                 int index = d_ptr->m_values.count();
                 d_ptr->append(QPointF(d_ptr->m_values.count(), value));
                 emit valuesAdded(index, 1);
             }
             /*!
                 Appends a list of reals to set. Works like append with single real value. The \a values in list
                 are appended to end of barset
                 \sa append()
             */
             void QBarSet::append(const QList<qreal> &values)
             {
                 int index = d_ptr->m_values.count();
                 d_ptr->append(values);
                 emit valuesAdded(index, values.count());
             }
             /*!
                 Convenience operator. Same as append, with real \a value.
                 \sa append()
             */
             QBarSet &QBarSet::operator << (const qreal &value)
             {
                 append(value);
                 return *this;
             }
             /*!
                 Inserts new \a value on the \a index position.
                 The value that is currently at this postion is moved to postion index + 1
                 \sa remove()
             */
             void QBarSet::insert(const int index, const qreal value)
             {
                 d_ptr->insert(index, value);
                 emit valuesAdded(index, 1);
             }
             /*!
                 Removes \a count number of values from the set starting at \a index.
                 \sa insert()
             */
             void QBarSet::remove(const int index, const int count)
             {
                 int removedCount = d_ptr->remove(index, count);
                 if (removedCount > 0)
                     emit valuesRemoved(index, removedCount);
                 return;
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::replace(const int index, const qreal value)
             {
                 if (index >= 0 && index < d_ptr->m_values.count()) {
                     d_ptr->replace(index, value);
                     emit valueChanged(index);
                 }
             }
             /*!
                 Returns value of set indexed by \a index.
                 If the index is out of bounds 0.0 is returned.
             */
             qreal QBarSet::at(const int index) const
             {
                 if (index < 0 || index >= d_ptr->m_values.count())
                     return 0;
                 return d_ptr->m_values.at(index).y();
             }
             /*!
                 Returns value of set indexed by \a index.
                 If the index is out of bounds 0.0 is returned.
             */
             qreal QBarSet::operator [](const int index) const
             {
                 return at(index);
             }
             /*!
                 Returns count of values in set.
             */
             int QBarSet::count() const
             {
                 return d_ptr->m_values.count();
             }
             /*!
                 Returns sum of all values in barset.
             */
             qreal QBarSet::sum() const
             {
                 qreal total(0);
                 for (int i = 0; i < d_ptr->m_values.count(); i++)
                     total += d_ptr->m_values.at(i).y();
                 return total;
             }
             /*!
                 Sets pen for set. Bars of this set are drawn using \a pen
             */
             void QBarSet::setPen(const QPen &pen)
             {
                 if (d_ptr->m_pen != pen) {
                     d_ptr->m_pen = pen;
                     emit d_ptr->updatedBars();
                     emit penChanged();
                 }
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBarSet::pen() const
             {
                 return d_ptr->m_pen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
             void QBarSet::setBrush(const QBrush &brush)
             {
                 if (d_ptr->m_brush != brush) {
                     d_ptr->m_brush = brush;
                     emit d_ptr->updatedBars();
                     emit brushChanged();
                 }
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush() const
             {
                 return d_ptr->m_brush;
             }
             /*!
                 Sets \a brush of the values that are drawn on top of this barset
             */
             void QBarSet::setLabelBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelBrush != brush) {
                     d_ptr->m_labelBrush = brush;
                     emit d_ptr->updatedBars();
                     emit labelBrushChanged();
                 }
             }
             /*!
                 Returns brush of the values that are drawn on top of this barset
             */
             QBrush QBarSet::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             /*!
                 Sets the \a font for values that are drawn on top of this barset
             */
             void QBarSet::setLabelFont(const QFont &font)
             {
                 if (d_ptr->m_labelFont != font) {
                     d_ptr->m_labelFont = font;
                     emit d_ptr->updatedBars();
                     emit labelFontChanged();
                 }
             }
             /*!
                 Returns the pen for values that are drawn on top of this barset
             */
             QFont QBarSet::labelFont() const
             {
                 return d_ptr->m_labelFont;
             }
             /*!
                 Returns the color of the brush of barset.
             */
             QColor QBarSet::color()
             {
                 return brush().color();
             }
             /*!
                 Sets the \a color of brush for this barset
             */
             void QBarSet::setColor(QColor color)
             {
                 QBrush b = brush();
                 if ((b.color() != color) || (b.style() == Qt::NoBrush)) {
                     b.setColor(color);
                     if (b.style() == Qt::NoBrush) {
                         // Set tyle to Qt::SolidPattern. (Default is Qt::NoBrush)
                         // This prevents theme to override color defined in QML side:
                         // BarSet { label: "Bob"; color:"red"; values: [1,2,3] }
                         // The color must be obeyed, since user wanted it.
                         b.setStyle(Qt::SolidPattern);
                     }
                     setBrush(b);
                     emit colorChanged(color);
                 }
             }
             /*!
                 Returns the color of pen of this barset
             */
             QColor QBarSet::borderColor()
             {
                 return pen().color();
             }
             /*!
                 Sets the color of pen for this barset
             */
             void QBarSet::setBorderColor(QColor color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             /*!
                 Returns the color of labels of this barset
             */
             QColor QBarSet::labelColor()
             {
                 return labelBrush().color();
             }
             /*!
                 Sets the color of labels for this barset
             */
             void QBarSet::setLabelColor(QColor color)
             {
                 QBrush b = labelBrush();
                 if (b == QBrush())
                     b.setStyle(Qt::SolidPattern);
                 if (b.color() != color) {
                     b.setColor(color);
                     setLabelBrush(b);
                     emit labelColorChanged(color);
                 }
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSetPrivate::QBarSetPrivate(const QString label, QBarSet *parent) : QObject(parent),
                 q_ptr(parent),
                 m_label(label)
             {
             }
             QBarSetPrivate::~QBarSetPrivate()
             {
             }
             void QBarSetPrivate::append(QPointF value)
             {
-                m_values.append(value);
+                if (isValidValue(value)) {
-                emit restructuredBars();
+                    m_values.append(value);
+                    emit restructuredBars();
+                }
             }
             void QBarSetPrivate::append(QList<QPointF> values)
             {
-                for (int i = 0; i < values.count(); i++)
+                for (int i = 0; i < values.count(); i++) {
-                    m_values.append(values.at(i));
+                    if (isValidValue(values.at(i)))
+                        m_values.append(values.at(i));
+                }
                 emit restructuredBars();
             }
             void QBarSetPrivate::append(QList<qreal> values)
             {
                 int index = m_values.count();
                 for (int i = 0; i < values.count(); i++) {
-                    m_values.append(QPointF(index, values.at(i)));
+                    if (isValidValue(values.at(i))) {
-                    index++;
+                        m_values.append(QPointF(index, values.at(i)));
+                        index++;
+                    }
                 }
                 emit restructuredBars();
             }
             void QBarSetPrivate::insert(const int index, const qreal value)
             {
                 m_values.insert(index, QPointF(index, value));
                 emit restructuredBars();
             }
             void QBarSetPrivate::insert(const int index, const QPointF value)
             {
                 m_values.insert(index, value);
                 emit restructuredBars();
             }
             int QBarSetPrivate::remove(const int index, const int count)
             {
                 int removeCount = count;
                 if ((index < 0) || (m_values.count() == 0))
                     return 0; // Invalid index or not values in list, remove nothing.
                 else if ((index + count) > m_values.count())
                     removeCount = m_values.count() - index; // Trying to remove more items than list has. Limit amount to be removed.
                 int c = 0;
                 while (c < removeCount) {
                     m_values.removeAt(index);
                     c++;
                 }
                 emit restructuredBars();
                 return removeCount;
             }
             void QBarSetPrivate::replace(const int index, const qreal value)
             {
                 m_values.replace(index, QPointF(index, value));
                 emit updatedLayout();
             }
             void QBarSetPrivate::replace(const int index, const QPointF value)
             {
                 m_values.replace(index, value);
                 emit updatedLayout();
             }
             qreal QBarSetPrivate::pos(const int index)
             {
                 if (index < 0 || index >= m_values.count())
                     return 0;
                 return m_values.at(index).x();
             }
             qreal QBarSetPrivate::value(const int index)
             {
                 if (index < 0 || index >= m_values.count())
                     return 0;
                 return m_values.at(index).y();
             }
             #include "moc_qbarset.cpp"
             #include "moc_qbarset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QBARSET_H
             #define QBARSET_H
             #include <qchartglobal.h>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
+            #include "charthelpers_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSetPrivate;
             class QTCOMMERCIALCHART_EXPORT QBarSet : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString label READ label WRITE setLabel NOTIFY labelChanged)
                 Q_PROPERTY(QPen pen READ pen WRITE setPen NOTIFY penChanged)
                 Q_PROPERTY(QBrush brush READ brush WRITE setBrush NOTIFY brushChanged)
                 Q_PROPERTY(QBrush labelBrush READ labelBrush WRITE setLabelBrush NOTIFY labelBrushChanged)
                 Q_PROPERTY(QFont labelFont READ labelFont WRITE setLabelFont NOTIFY labelFontChanged)
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
                 Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor NOTIFY borderColorChanged)
                 Q_PROPERTY(QColor labelColor READ labelColor WRITE setLabelColor NOTIFY labelColorChanged)
             public:
                 explicit QBarSet(const QString label, QObject *parent = 0);
                 virtual ~QBarSet();
                 void setLabel(const QString label);
                 QString label() const;
                 void append(const qreal value);
                 void append(const QList<qreal> &values);
                 QBarSet &operator << (const qreal &value);
                 void insert(const int index, const qreal value);
                 void remove(const int index, const int count = 1);
                 void replace(const int index, const qreal value);
                 qreal at(const int index) const;
                 qreal operator [](const int index) const;
                 int count() const;
                 qreal sum() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setLabelBrush(const QBrush &brush);
                 QBrush labelBrush() const;
                 void setLabelFont(const QFont &font);
                 QFont labelFont() const;
                 QColor color();
                 void setColor(QColor color);
                 QColor borderColor();
                 void setBorderColor(QColor color);
                 QColor labelColor();
                 void setLabelColor(QColor color);
             Q_SIGNALS:
                 void clicked(int index);
                 void hovered(bool status);
                 void penChanged();
                 void brushChanged();
                 void labelChanged();
                 void labelBrushChanged();
                 void labelFontChanged();
                 void colorChanged(QColor color);
                 void borderColorChanged(QColor color);
                 void labelColorChanged(QColor color);
                 void valuesAdded(int index, int count);
                 void valuesRemoved(int index, int count);
                 void valueChanged(int index);
             private:
                 QScopedPointer<QBarSetPrivate> d_ptr;
                 Q_DISABLE_COPY(QBarSet)
                 friend class QAbstractBarSeries;
                 friend class BarLegendMarker;
                 friend class AbstractBarChartItem;
                 friend class QAbstractBarSeriesPrivate;
                 friend class StackedBarChartItem;
                 friend class PercentBarChartItem;
                 friend class BarChartItem;
                 friend class HorizontalBarChartItem;
                 friend class HorizontalStackedBarChartItem;
                 friend class HorizontalPercentBarChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSET_H

src/piechart/qpieseries.cpp +14 -3

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

src/src.pro +2 -1

             !include( ../config.pri ):error( "Couldn't find the config.pri file!" )
             ############################# BUILD CONFIG ######################################
             TARGET = $$LIBRARY_NAME
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT = core gui
             greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
             DEFINES += QTCOMMERCIALCHART_LIBRARY
             win32:CONFIG += create_prl
             # treat warnings as errors
             win32-msvc*: {
                 QMAKE_CXXFLAGS += /WX
             } else {
             #    QMAKE_CXXFLAGS += -Werror
             }
             unix:{
               QMAKE_CXXFLAGS += -fvisibility=hidden -fvisibility-inlines-hidden
             }
             ############################# DEPEDENCES ########################################
             win32-msvc*: LIBS += User32.lib
             LIBS -= -l$$LIBRARY_NAME
             INCLUDEPATH += ../include .
             ############################# SOURCES ##########################################
             SOURCES += \
                 $$PWD/chartdataset.cpp \
                 $$PWD/chartpresenter.cpp \
                 $$PWD/chartthememanager.cpp \
                 $$PWD/qchart.cpp \
                 $$PWD/qchartview.cpp \
                 $$PWD/qabstractseries.cpp \
                 $$PWD/chartbackground.cpp \
                 $$PWD/chartelement.cpp \
                 $$PWD/chartitem.cpp \
                 $$PWD/scroller.cpp \
                 $$PWD/chartlayout.cpp \
                 $$PWD/charttitle.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartdataset_p.h \
                 $$PWD/chartitem_p.h \
                 $$PWD/chartpresenter_p.h \
                 $$PWD/chartthememanager_p.h \
                 $$PWD/chartbackground_p.h \
                 $$PWD/chartelement_p.h \
                 $$PWD/chartconfig_p.h \
                 $$PWD/qchart_p.h \
                 $$PWD/qchartview_p.h \
                 $$PWD/scroller_p.h \
                 $$PWD/qabstractseries_p.h \
                 $$PWD/chartlayout_p.h \
-                $$PWD/charttitle_p.h
+                $$PWD/charttitle_p.h \
+                $$PWD/charthelpers_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qchart.h \
                 $$PWD/qchartglobal.h \
                 $$PWD/qabstractseries.h \
                 $$PWD/qchartview.h \
                 $$PWD/chartsnamespace.h
             include(animations/animations.pri)
             include(areachart/areachart.pri)
             include(axis/axis.pri)
             include(domain/domain.pri)
             include(barchart/barchart.pri)
             include(legend/legend.pri)
             include(linechart/linechart.pri)
             include(piechart/piechart.pri)
             include(scatterchart/scatter.pri)
             include(splinechart/splinechart.pri)
             include(themes/themes.pri)
             include(xychart/xychart.pri)
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             ############################# BUILD PATH ##########################################
             OBJECTS_DIR = $$CHART_BUILD_DIR/lib
             MOC_DIR = $$CHART_BUILD_DIR/lib
             UI_DIR = $$CHART_BUILD_DIR/lib
             RCC_DIR = $$CHART_BUILD_DIR/lib
             ############################# PUBLIC HEADERS GENERATOR ##########################################
             !exists($$CHART_BUILD_PUBLIC_HEADER_DIR/QChartGlobal)
             {
                 system($$QMAKE_MKDIR $$CHART_BUILD_PUBLIC_HEADER_DIR)
                  win32:{
                     command = "echo $${LITERAL_HASH}include \"qchartglobal.h\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/QChartGlobal"
                 }else{
                     command = "echo \"$${LITERAL_HASH}include \\\"qchartglobal.h\\\"\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/QChartGlobal"
                 }
                 PUBLIC_QT_HEADERS += $$CHART_BUILD_PUBLIC_HEADER_DIR/QChartGlobal
                 system($$command)
             }
             for(file, PUBLIC_HEADERS) {
                 name = $$split(file,'/')
                 name = $$last(name)
                 class = "$$cat($$file)"
                 class = $$find(class,class)
                 !isEmpty(class){
                 class = $$split(class,QTCOMMERCIALCHART_EXPORT)
                 class = $$member(class,1)
                 class = $$split(class,' ')
                 class = $$replace(class,' ','')
                 class = $$member(class,0)
                 win32:{
                     command = "echo $${LITERAL_HASH}include \"$$name\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/$$class"
                 }else{
                     command = "echo \"$${LITERAL_HASH}include \\\"$$name\\\"\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/$$class"
                 }
                 PUBLIC_QT_HEADERS += $$CHART_BUILD_PUBLIC_HEADER_DIR/$$class
                 system($$command)
                 }
             }
             ############################# INSTALLERS ##########################################
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS $$PUBLIC_QT_HEADERS
             INSTALLS += public_headers
             install_build_public_headers.name = build_public_headers
             install_build_public_headers.output = $$CHART_BUILD_PUBLIC_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_public_headers.input = PUBLIC_HEADERS
             install_build_public_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PUBLIC_HEADER_DIR
             install_build_public_headers.CONFIG += target_predeps \
                 no_link
             install_build_private_headers.name = build_private_headers
             install_build_private_headers.output = $$CHART_BUILD_PRIVATE_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_private_headers.input = PRIVATE_HEADERS
             install_build_private_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PRIVATE_HEADER_DIR
             install_build_private_headers.CONFIG += target_predeps \
                 no_link
             QMAKE_EXTRA_COMPILERS += install_build_public_headers \
                 install_build_private_headers \
             win32:{
                bintarget.CONFIG += no_check_exist
                !staticlib: {
                   bintarget.files += $$CHART_BUILD_LIB_DIR\\$${TARGET}.dll
                }
                win32-msvc*:CONFIG(debug, debug|release): {
                   bintarget.files += $$CHART_BUILD_LIB_DIR\\$${TARGET}.pdb
                }
                bintarget.path = $$[QT_INSTALL_BINS]
                libtarget.CONFIG += no_check_exist
                libtarget.files = $$CHART_BUILD_LIB_DIR\\$${TARGET}.prl
                win32-msvc*: {
                   libtarget.files += $$CHART_BUILD_LIB_DIR\\$${TARGET}.lib
                } else {
                   libtarget.files += $$CHART_BUILD_LIB_DIR\\lib$${TARGET}.a
                }
                libtarget.path = $$[QT_INSTALL_LIBS]
                DLLDESTDIR = $$CHART_BUILD_BIN_DIR
                INSTALLS += bintarget libtarget
             }else{
                target.path=$$[QT_INSTALL_LIBS]
                INSTALLS += target
             }
             mac: !staticlib: {
                 # Update the name (id) of the library on OSX to point to the lib path
                 MAC_CHARTS_LIB_NAME = "lib"$$LIBRARY_NAME".1.dylib"
                 QMAKE_POST_LINK += "install_name_tool -id $$CHART_BUILD_LIB_DIR"/"$$MAC_CHARTS_LIB_NAME $$CHART_BUILD_LIB_DIR"/"$$MAC_CHARTS_LIB_NAME"
                 # Update the name (id) of the installed library on OSX to point to the installation path
                 postinstall.path = $$[QT_INSTALL_LIBS]
                 postinstall.extra = "install_name_tool -id $$[QT_INSTALL_LIBS]"/"$$MAC_CHARTS_LIB_NAME $$[QT_INSTALL_LIBS]"/"$$MAC_CHARTS_LIB_NAME"
                 INSTALLS += postinstall
             }
             ################################ DEVELOPMENT BUILD ##########################################
             # There is a problem with jom.exe currently. It does not seem to understand QMAKE_EXTRA_TARGETS properly.
             # This is the case at least with shadow builds.
             # http://qt-project.org/wiki/jom
             development_build:!win32-msvc*:{
                 chartversion.target = $$PWD/qchartversion_p.h
                 unix:{
                     chartversion.commands = @echo \
                         \" $${LITERAL_HASH}ifndef QCHARTVERSION_P_H\\n\
                         $${LITERAL_HASH}define QCHARTVERSION_P_H\\n\
                         const char *buildTime = \\\"`date +'%y%m%d%H%M'`\\\" ; \\n\
                         const char *gitHead = \\\"`git rev-parse HEAD`\\\" ; \\n \
                         $${LITERAL_HASH}endif \"  \
                         > \
                         $$chartversion.target;
                 }else{
                     chartversion.commands = @echo \
                         "const char *buildTime = \"%date%_%time%\" ; \
                          const char *gitHead = \"unknown\" ; " \
                         > \
                         $$chartversion.target
                 }
                 chartversion.depends = $$HEADERS \
                     $$SOURCES
                 PRE_TARGETDEPS += $$chartversion.target
                 QMAKE_CLEAN += $$PWD/qchartversion_p.h
                 QMAKE_EXTRA_TARGETS += chartversion
             }
             ############################### CLEAN ###########################################
             unix:QMAKE_DISTCLEAN += -r \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             win32:QMAKE_DISTCLEAN += /Q \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             ############################## COVERAGE #########################################
             unix:coverage:{
             QMAKE_CXXFLAGS += -fprofile-arcs -ftest-coverage
             QMAKE_LDFLAGS += -fprofile-arcs -ftest-coverage
             LIBS += -lgcov
             QMAKE_CLEAN += $$OBJECTS_DIR/*.gcda $$OBJECTS_DIR/*.gcno $$PWD/*.gcov ../coverage/*.info
             QMAKE_EXTRA_TARGETS += preparecoverage gencoverage
             preparecoverage.target = prepare_coverage
             preparecoverage.depends = all
             preparecoverage.commands =  lcov --directory $$OBJECTS_DIR --zerocounters ;\
                                         lcov -i -d $$OBJECTS_DIR -c -o ../coverage/base.info -b $$PWD;
             gencoverage.target = gen_coverage
             gencoverage.depends = all
             gencoverage.commands = lcov -d $$OBJECTS_DIR -c -o ../coverage/src.info -b $$PWD;\
                                    lcov -e ../coverage/base.info $$PWD/* $$PWD/animations/* $$PWD/areachart/* $$PWD/axis/* $$PWD/barchart/* $$PWD/legend/* $$PWD/linechart/* $$PWD/piechart/* $$PWD/scatterchart/* $$PWD/splinechart/* $$PWD/themes/* $$PWD/xychart/* -o ../coverage/base.info;\
                                    lcov -e ../coverage/src.info $$PWD/* $$PWD/animations/* $$PWD/areachart/* $$PWD/axis/* $$PWD/barchart/* $$PWD/legend/* $$PWD/linechart/* $$PWD/piechart/* $$PWD/scatterchart/* $$PWD/splinechart/* $$PWD/themes/* $$PWD/xychart/* -o ../coverage/src.info;\
                                    lcov -a ../coverage/base.info -a ../coverage/src.info -o ../coverage/coverage.info;
             }

src/xychart/qxyseries.cpp +14 -6

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "abstractdomain_p.h"
             #include "qvalueaxis.h"
             #include "xychart_p.h"
             #include "qxylegendmarker.h"
+            #include "charthelpers_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                 \qmlclass XYSeries
                 \inherits AbstractSeries
                 The XYSeries class is a base class for line, spline and scatter series.
                 The class cannot be instantiated directly.
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisX
                 The x axis used for the series. If you leave both axisX and axisXTop undefined, a ValueAxis is created for
                 the series.
                 \sa axisXTop
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisY
                 The y axis used for the series. If you leave both axisY and axisYRight undefined, a ValueAxis is created for
                 the series.
                 \sa axisYRight
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisXTop
                 The x axis used for the series, drawn on top of the chart view. Note that you can only provide either axisX or
                 axisXTop, but not both.
                 \sa axisX
             */
             /*!
                 \qmlproperty AbstractAxis XYSeries::axisYRight
                 The y axis used for the series, drawn to the right on the chart view. Note that you can only provide either axisY
                 or axisYRight, but not both.
                 \sa axisY
             */
             /*!
                 \property QXYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                 \qmlproperty bool XYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \property QXYSeries::color
                 The color of the series. This is line (pen) color in case of QLineSeries or QSplineSeries and
                 fill (brush) color in case of QScatterSeries or QAreaSeries.
                 \sa QXYSeries::pen(), QXYSeries::brush()
             */
             /*!
                 \qmlproperty color XYSeries::color
                 The color of the series. This is line (pen) color in case of LineSeries or SplineSeries and
                 fill (brush) color in case of ScatterSeries or AreaSeries.
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart.
             */
             /*!
                 \qmlsignal XYSeries::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on chart. For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onClicked: console.log("onClicked: " + point.x + ", " + point.y);
                 }
                 \endcode
             */
             /*!
                 \fn void QXYSeries::hovered(const QPointF &point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \qmlsignal XYSeries::onHovered(point point, bool state)
                 This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate)
                 of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from
                 the series.
             */
             /*!
                 \fn void QXYSeries::pointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
             */
             /*!
                 \fn void QXYSeries::pointsReplaced()
                 Signal is emitted when all points have been replaced with another points.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointsReplaced()
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal XYSeries::onPointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
                 \sa remove()
             */
             /*!
                 \qmlsignal XYSeries::onPointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
             */
             /*!
                 \fn void QXYSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \qmlsignal XYSeries::onColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \qmlmethod XYSeries::append(real x, real y)
                 Append point (\a x, \a y) to the series
             */
             /*!
                 \qmlmethod XYSeries::replace(real oldX, real oldY, real newX, real newY)
                 Replaces point (\a oldX, \a oldY) with point (\a newX, \a newY). Does nothing, if point (oldX, oldY) does not
                 exist.
             */
             /*!
                 \qmlmethod XYSeries::remove(real x, real y)
                 Removes point (\a x, \a y) from the series. Does nothing, if point (x, y) does not exist.
             */
             /*!
                 \qmlmethod XYSeries::insert(int index, real x, real y)
                 Inserts point (\a x, \a y) to the \a index. If index is 0 or smaller than 0 the point is prepended to the list of
                 points. If index is the same as or bigger than count, the point is appended to the list of points.
             */
             /*!
                 \qmlmethod QPointF XYSeries::at(int index)
                 Returns point at \a index. Returns (0, 0) if the index is not valid.
             */
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QXYSeries::QXYSeries(QXYSeriesPrivate &d, QObject *parent)
                 : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(qreal x, qreal y)
             {
                 append(QPointF(x, y));
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QPointF &point)
             {
                 Q_D(QXYSeries);
-                d->m_points << point;
-                emit pointAdded(d->m_points.count() - 1);
+                if (isValidValue(point)) {
+                    d->m_points << point;
+                    emit pointAdded(d->m_points.count() - 1);
+                }
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QList<QPointF> &points)
             {
                 foreach (const QPointF &point , points)
                     append(point);
             }
             /*!
               Replaces data point \a oldX \a oldY with data point \a newX \a newY.
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(qreal oldX, qreal oldY, qreal newX, qreal newY)
             {
                 replace(QPointF(oldX, oldY), QPointF(newX, newY));
             }
             /*!
               Replaces \a oldPoint with \a newPoint.
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(const QPointF &oldPoint, const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(oldPoint);
                 if (index == -1)
                     return;
-                d->m_points[index] = newPoint;
+                if (isValidValue(newPoint)) {
-                emit pointReplaced(index);
+                    d->m_points[index] = newPoint;
+                    emit pointReplaced(index);
+                }
             }
             /*!
               Replaces the current points with \a points. This is faster than replacing data points one by one,
               or first clearing all data, and then appending the new data. Emits QXYSeries::pointsReplaced()
               when the points have been replaced.
               \sa QXYSeries::pointsReplaced()
             */
             void QXYSeries::replace(QList<QPointF> points)
             {
                 Q_D(QXYSeries);
                 d->m_points = points.toVector();
                 emit pointsReplaced();
             }
             /*!
               Removes current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x, qreal y)
             {
                 remove(QPointF(x, y));
             }
             /*!
               Removes current \a point x value.
               Note: point y value is ignored.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if (index == -1)
                     return;
                 d->m_points.remove(index);
                 emit pointRemoved(index);
             }
             /*!
                Inserts a \a point in the series at \a index position.
             */
             void QXYSeries::insert(int index, const QPointF &point)
             {
                 Q_D(QXYSeries);
-                d->m_points.insert(index, point);
+                if (isValidValue(point)) {
-                emit pointAdded(index);
+                    d->m_points.insert(index, point);
+                    emit pointAdded(index);
+                }
             }
             /*!
                 Removes all points from the series.
             */
             void QXYSeries::clear()
             {
                 Q_D(QXYSeries);
                 for (int i = d->m_points.size() - 1; i >= 0; i--)
                     remove(d->m_points.at(i));
             }
             /*!
                 Returns list of points in the series.
             */
             QList<QPointF> QXYSeries::points() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.toList();
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.count();
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen != pen) {
                     bool emitColorChanged = d->m_pen.color() != pen.color();
                     d->m_pen = pen;
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(pen.color());
                 }
             }
             QPen QXYSeries::pen() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QXYSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QXYSeries::brush() const
             {
                 Q_D(const QXYSeries);
                 return d->m_brush;
             }
             void QXYSeries::setColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QXYSeries::color() const
             {
                 return pen().color();
             }
             void QXYSeries::setPointsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             bool QXYSeries::pointsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointsVisible;
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa append()
             */
             QXYSeries &QXYSeries::operator<< (const QPointF &point)
             {
                 append(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa append()
             */
             QXYSeries &QXYSeries::operator<< (const QList<QPointF>& points)
             {
                 append(points);
                 return *this;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q)
                 : QAbstractSeriesPrivate(q),
                   m_pointsVisible(false)
             {
             }
             void QXYSeriesPrivate::initializeDomain()
             {
                 qreal minX(0);
                 qreal minY(0);
                 qreal maxX(1);
                 qreal maxY(1);
                 Q_Q(QXYSeries);
                 const QList<QPointF>& points = q->points();
                 if (!points.isEmpty()) {
                     minX = points[0].x();
                     minY = points[0].y();
                     maxX = minX;
                     maxY = minY;
                     for (int i = 0; i < points.count(); i++) {
                         qreal x = points[i].x();
                         qreal y = points[i].y();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                     }
                 }
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             QList<QLegendMarker*> QXYSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<QLegendMarker*> list;
                 return list << new QXYLegendMarker(q,legend);
             }
             void QXYSeriesPrivate::initializeAxes()
             {
             }
             QAbstractAxis::AxisType QXYSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValue;
             }
             QAbstractAxis* QXYSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return 0;
             }
             void QXYSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
             {
                 XYChart *item = static_cast<XYChart *>(m_item.data());
                 Q_ASSERT(item);
                 if (options.testFlag(QChart::SeriesAnimations)) {
                     item->setAnimation(new XYAnimation(item));
                 }else{
                     item->setAnimation(0);
                 }
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

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

No TODOs yet

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

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