HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2242:2523dbee7254

Replaced qFuzzyIsNull with qFuzzyCompare. Once qchart test case still uses qFuzzyIsNull becasue it started failing when qFuzzyCompare was used

Marek Rosa -

r2242:2523dbee7254

parent child

Context file:

r2242:2523dbee7254

Expand all files

demos/piechartcustomization/pentool.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "pentool.h"
             #include <QPushButton>
             #include <QDoubleSpinBox>
             #include <QComboBox>
             #include <QFormLayout>
             #include <QColorDialog>
             PenTool::PenTool(QString title, QWidget *parent)
                 : QWidget(parent)
             {
                 setWindowTitle(title);
                 setWindowFlags(Qt::Tool);
                 m_colorButton = new QPushButton();
                 m_widthSpinBox = new QDoubleSpinBox();
                 m_styleCombo = new QComboBox();
                 m_styleCombo->addItem("NoPen");
                 m_styleCombo->addItem("SolidLine");
                 m_styleCombo->addItem("DashLine");
                 m_styleCombo->addItem("DotLine");
                 m_styleCombo->addItem("DashDotLine");
                 m_styleCombo->addItem("DashDotDotLine");
                 m_capStyleCombo = new QComboBox();
                 m_capStyleCombo->addItem("FlatCap", Qt::FlatCap);
                 m_capStyleCombo->addItem("SquareCap", Qt::SquareCap);
                 m_capStyleCombo->addItem("RoundCap", Qt::RoundCap);
                 m_joinStyleCombo = new QComboBox();
                 m_joinStyleCombo->addItem("MiterJoin", Qt::MiterJoin);
                 m_joinStyleCombo->addItem("BevelJoin", Qt::BevelJoin);
                 m_joinStyleCombo->addItem("RoundJoin", Qt::RoundJoin);
                 m_joinStyleCombo->addItem("SvgMiterJoin", Qt::SvgMiterJoin);
                 QFormLayout *layout = new QFormLayout();
                 layout->addRow("Color", m_colorButton);
                 layout->addRow("Width", m_widthSpinBox);
                 layout->addRow("Style", m_styleCombo);
                 layout->addRow("Cap style", m_capStyleCombo);
                 layout->addRow("Join style", m_joinStyleCombo);
                 setLayout(layout);
                 connect(m_colorButton, SIGNAL(clicked()), this, SLOT(showColorDialog()));
                 connect(m_widthSpinBox, SIGNAL(valueChanged(double)), this, SLOT(updateWidth(double)));
                 connect(m_styleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateStyle(int)));
                 connect(m_capStyleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateCapStyle(int)));
                 connect(m_joinStyleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateJoinStyle(int)));
             }
             void PenTool::setPen(const QPen &pen)
             {
                 m_pen = pen;
                 m_colorButton->setText(m_pen.color().name());
                 m_widthSpinBox->setValue(m_pen.widthF());
                 m_styleCombo->setCurrentIndex(m_pen.style()); // index matches the enum
                 m_capStyleCombo->setCurrentIndex(m_capStyleCombo->findData(m_pen.capStyle()));
                 m_joinStyleCombo->setCurrentIndex(m_joinStyleCombo->findData(m_pen.joinStyle()));
             }
             QPen PenTool::pen() const
             {
                 return m_pen;
             }
             QString PenTool::name()
             {
                 return name(m_pen);
             }
             QString PenTool::name(const QPen &pen)
             {
                 return pen.color().name() + ":" + QString::number(pen.widthF());
             }
             void PenTool::showColorDialog()
             {
                 QColorDialog dialog(m_pen.color());
                 dialog.show();
                 dialog.exec();
                 m_pen.setColor(dialog.selectedColor());
                 m_colorButton->setText(m_pen.color().name());
                 emit changed();
             }
             void PenTool::updateWidth(double width)
             {
-                if (!qFuzzyIsNull(width - m_pen.widthF())) {
+                if (!qFuzzyCompare(width, m_pen.widthF())) {
                     m_pen.setWidthF(width);
                     emit changed();
                 }
             }
             void PenTool::updateStyle(int style)
             {
                 if (m_pen.style() != style) {
                     m_pen.setStyle((Qt::PenStyle) style);
                     emit changed();
                 }
             }
             void PenTool::updateCapStyle(int index)
             {
                 Qt::PenCapStyle capStyle = (Qt::PenCapStyle) m_capStyleCombo->itemData(index).toInt();
                 if (m_pen.capStyle() != capStyle) {
                     m_pen.setCapStyle(capStyle);
                     emit changed();
                 }
             }
             void PenTool::updateJoinStyle(int index)
             {
                 Qt::PenJoinStyle joinStyle = (Qt::PenJoinStyle) m_joinStyleCombo->itemData(index).toInt();
                 if (m_pen.joinStyle() != joinStyle) {
                     m_pen.setJoinStyle(joinStyle);
                     emit changed();
                 }
             }
             #include "moc_pentool.cpp"

src/axis/chartaxis.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartaxis_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
             #include "chartlayout_p.h"
             #include "domain_p.h"
             #include <qmath.h>
             #include <QDateTime>
             #include <QValueAxis>
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxis::ChartAxis(QAbstractAxis *axis, ChartPresenter *presenter, bool intervalAxis)
                 : ChartElement(presenter),
                   m_chartAxis(axis),
                   m_labelsAngle(0),
                   m_grid(new QGraphicsItemGroup(presenter->rootItem())),
                   m_shades(new QGraphicsItemGroup(presenter->rootItem())),
                   m_labels(new QGraphicsItemGroup(presenter->rootItem())),
                   m_arrow(new QGraphicsItemGroup(presenter->rootItem())),
                   m_title(new QGraphicsSimpleTextItem(presenter->rootItem())),
                   m_min(0),
                   m_max(0),
                   m_animation(0),
                   m_labelPadding(5),
                   m_intervalAxis(intervalAxis)
             {
                 //initial initialization
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_arrow->setHandlesChildEvents(false);
                 m_labels->setZValue(ChartPresenter::AxisZValue);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 m_title->setZValue(ChartPresenter::GridZValue);
                 QObject::connect(m_chartAxis->d_ptr.data(), SIGNAL(updated()), this, SLOT(handleAxisUpdated()));
                 QGraphicsSimpleTextItem item;
                 m_font = item.font();
             }
             ChartAxis::~ChartAxis()
             {
             }
             void ChartAxis::setAnimation(AxisAnimation *animation)
             {
                 m_animation = animation;
             }
             void ChartAxis::setLayout(QVector<qreal> &layout)
             {
                 m_layoutVector = layout;
             }
             void ChartAxis::createItems(int count)
             {
                 if (m_arrow->childItems().size() == 0)
                     m_arrow->addToGroup(new AxisItem(this, presenter()->rootItem()));
                 if (m_intervalAxis && m_grid->childItems().size() == 0) {
                     for (int i = 0 ; i < 2 ; i  ++)
                         m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                 }
                 for (int i = 0; i < count; ++i) {
                     m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                     QGraphicsSimpleTextItem *label = new QGraphicsSimpleTextItem(presenter()->rootItem());
                     label->setFont(m_font);
                     m_labels->addToGroup(label);
                     m_arrow->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                     if ((m_grid->childItems().size()) % 2 && m_grid->childItems().size() > 2)
                         m_shades->addToGroup(new QGraphicsRectItem(presenter()->rootItem()));
                 }
             }
             void ChartAxis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 for (int i = 0; i < count; ++i) {
                     if (lines.size() % 2 && lines.size() > 1)
                         delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void ChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 int diff = m_layoutVector.size() - layout.size();
                 if (diff > 0)
                     deleteItems(diff);
                 else if (diff < 0)
                     createItems(-diff);
                 if (diff < 0) handleAxisUpdated();
                 if (m_animation) {
                     switch (presenter()->state()) {
                     case ChartPresenter::ZoomInState:
                         m_animation->setAnimationType(AxisAnimation::ZoomInAnimation);
                         m_animation->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ZoomOutState:
                         m_animation->setAnimationType(AxisAnimation::ZoomOutAnimation);
                         m_animation->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ScrollUpState:
                     case ChartPresenter::ScrollLeftState:
                         m_animation->setAnimationType(AxisAnimation::MoveBackwordAnimation);
                         break;
                     case ChartPresenter::ScrollDownState:
                     case ChartPresenter::ScrollRightState:
                         m_animation->setAnimationType(AxisAnimation::MoveForwardAnimation);
                         break;
                     case ChartPresenter::ShowState:
                         m_animation->setAnimationType(AxisAnimation::DefaultAnimation);
                         break;
                     }
                     m_animation->setValues(m_layoutVector, layout);
                     presenter()->startAnimation(m_animation);
                 } else {
                     setLayout(layout);
                     updateGeometry();
                 }
             }
             void ChartAxis::setArrowOpacity(qreal opacity)
             {
                 m_arrow->setOpacity(opacity);
             }
             qreal ChartAxis::arrowOpacity() const
             {
                 return m_arrow->opacity();
             }
             void ChartAxis::setArrowVisibility(bool visible)
             {
                 m_arrow->setOpacity(visible);
             }
             void ChartAxis::setGridOpacity(qreal opacity)
             {
                 m_grid->setOpacity(opacity);
             }
             qreal ChartAxis::gridOpacity() const
             {
                 return m_grid->opacity();
             }
             void ChartAxis::setGridVisibility(bool visible)
             {
                 m_grid->setOpacity(visible);
             }
             void ChartAxis::setLabelsOpacity(qreal opacity)
             {
                 m_labels->setOpacity(opacity);
             }
             qreal ChartAxis::labelsOpacity() const
             {
                 return m_labels->opacity();
             }
             void ChartAxis::setLabelsVisibility(bool visible)
             {
                 m_labels->setOpacity(visible);
             }
             void ChartAxis::setShadesOpacity(qreal opacity)
             {
                 m_shades->setOpacity(opacity);
             }
             qreal ChartAxis::shadesOpacity() const
             {
                 return m_shades->opacity();
             }
             void ChartAxis::setShadesVisibility(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxis::setLabelsAngle(int angle)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     item->setRotation(angle);
                 m_labelsAngle = angle;
             }
             void ChartAxis::setLabelsPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setPen(pen);
             }
             void ChartAxis::setLabelsBrush(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setBrush(brush);
             }
             void ChartAxis::setLabelsFont(const QFont &font)
             {
                 if (m_font != font) {
                     m_font = font;
                     foreach (QGraphicsItem *item , m_labels->childItems())
                         static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxis::setShadesBrush(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setBrush(brush);
             }
             void ChartAxis::setShadesPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setPen(pen);
             }
             void ChartAxis::setArrowPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_arrow->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::setGridPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_grid->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::setLabelPadding(int padding)
             {
                 m_labelPadding = padding;
             }
             bool ChartAxis::isEmpty()
             {
-                return m_axisRect.isEmpty() || m_gridRect.isEmpty() || qFuzzyIsNull(m_min - m_max);
+                return m_axisRect.isEmpty() || m_gridRect.isEmpty() || qFuzzyCompare(m_min, m_max);
             }
             void ChartAxis::handleDomainUpdated()
             {
                 Domain *domain = qobject_cast<Domain *>(sender());
                 qreal min(0);
                 qreal max(0);
                 if (m_chartAxis->orientation() == Qt::Horizontal) {
                     min = domain->minX();
                     max = domain->maxX();
                 } else if (m_chartAxis->orientation() == Qt::Vertical) {
                     min = domain->minY();
                     max = domain->maxY();
                 }
-                if (!qFuzzyIsNull(m_min - min) || !qFuzzyIsNull(m_max - max)) {
+                if (!qFuzzyCompare(m_min, min) || !qFuzzyCompare(m_max, max)) {
                     m_min = min;
                     m_max = max;
                     if (!isEmpty()) {
                         QVector<qreal> layout = calculateLayout();
                         updateLayout(layout);
                         QSizeF before = effectiveSizeHint(Qt::PreferredSize);
                         QSizeF after = sizeHint(Qt::PreferredSize);
                         if (before != after) {
                             QGraphicsLayoutItem::updateGeometry();
                             //we don't want to call invalidate on layout, since it will change minimum size of component,
                             //which we would like to avoid since it causes nasty flips when scrolling or zooming,
                             //instead recalculate layout and use plotArea for extra space.
                             presenter()->layout()->setGeometry(presenter()->layout()->geometry());
                         }
                     }
                 }
             }
             void ChartAxis::handleAxisUpdated()
             {
                 if (isEmpty())
                     return;
                 bool visible = m_chartAxis->isVisible();
                 //TODO: split this into separate signal/slots ?
                 setArrowVisibility(visible && m_chartAxis->isLineVisible());
                 setGridVisibility(visible && m_chartAxis->isGridLineVisible());
                 setLabelsVisibility(visible && m_chartAxis->labelsVisible());
                 setShadesVisibility(visible && m_chartAxis->shadesVisible());
                 setLabelsAngle(m_chartAxis->labelsAngle());
                 setArrowPen(m_chartAxis->linePen());
                 setLabelsPen(m_chartAxis->labelsPen());
                 setLabelsBrush(m_chartAxis->labelsBrush());
                 setLabelsFont(m_chartAxis->labelsFont());
                 setGridPen(m_chartAxis->gridLinePen());
                 setShadesPen(m_chartAxis->shadesPen());
                 setShadesBrush(m_chartAxis->shadesBrush());
                 setTitleText(m_chartAxis->title());
                 setTitleFont(m_chartAxis->titleFont());
                 setTitlePen(m_chartAxis->titlePen());
                 setTitleBrush(m_chartAxis->titleBrush());
             }
             void ChartAxis::setTitleText(const QString &title)
             {
                 if (m_titleText != title) {
                     m_titleText = title;
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxis::setTitlePen(const QPen &pen)
             {
                 m_title->setPen(pen);
             }
             void ChartAxis::setTitleBrush(const QBrush &brush)
             {
                 m_title->setBrush(brush);
             }
             void ChartAxis::setTitleFont(const QFont &font)
             {
                 if(m_title->font() != font){
                     m_title->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             QFont ChartAxis::titleFont() const
             {
                 return  m_title->font();
             }
             void ChartAxis::hide()
             {
                 setArrowVisibility(false);
                 setGridVisibility(false);
                 setLabelsVisibility(false);
                 setShadesVisibility(false);
             }
             void ChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
             {
                 m_gridRect = grid;
                 m_axisRect = axis;
                 if (isEmpty())
                     return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             void ChartAxis::axisSelected()
             {
                 //TODO: axis clicked;
             }
             Qt::Orientation ChartAxis::orientation() const
             {
                 return m_chartAxis->orientation();
             }
             Qt::Alignment ChartAxis::alignment() const
             {
                 return m_chartAxis->alignment();
             }
             bool ChartAxis::isVisible()
             {
                 return m_chartAxis->isVisible();
             }
             void ChartAxis::setLabels(const QStringList &labels)
             {
                 m_labelsList = labels;
             }
             QStringList ChartAxis::createValueLabels(int ticks) const
             {
                 Q_ASSERT(m_max > m_min);
                 Q_ASSERT(ticks > 1);
                 QStringList labels;
                 int n = qMax(int(-qFloor(log10((m_max - m_min) / (ticks - 1)))), 0);
                 n++;
                 QValueAxis *axis = qobject_cast<QValueAxis *>(m_chartAxis);
                 QString format = axis->labelFormat();
                 if (format.isNull()) {
                     for (int i = 0; i < ticks; i++) {
                         qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));
                         labels << QString::number(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     for (int i = 0; i < ticks; i++) {
                         qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));
                         labels << QString().sprintf(array, value);
                     }
                 }
                 return labels;
             }
             QStringList ChartAxis::createDateTimeLabels(const QString &format, int ticks) const
             {
                 Q_ASSERT(m_max > m_min);
                 Q_ASSERT(ticks > 1);
                 QStringList labels;
                 int n = qMax(int(-floor(log10((m_max - m_min) / (ticks - 1)))), 0);
                 n++;
                 for (int i = 0; i < ticks; i++) {
                     qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));
                     labels << QDateTime::fromMSecsSinceEpoch(value).toString(format);
                 }
                 return labels;
             }
             QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF();
             }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/qvalueaxis.cpp +3 -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 "qvalueaxis.h"
             #include "qvalueaxis_p.h"
             #include "chartvalueaxisx_p.h"
             #include "chartvalueaxisy_p.h"
             #include "domain_p.h"
             #include "chartdataset_p.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QValueAxis
                 \brief The QValueAxis class is used for manipulating chart's axis.
                 \mainclass
                 ValueAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Values of axis are drawn to position of ticks.
                 Example code on how to use QValueAxis.
                 \code
                 QChartView *chartView = new QChartView;
                 QLineSeries *series = new QLineSeries;
                 // ...
                 chartView->chart()->addSeries(series);
                 QValueAxis *axisX = new QValueAxis;
                 axisX->setRange(10, 20.5);
                 axisX->setTickCount(10);
                 axisX->setLabelFormat("%.2f");
                 chartView->chart()->setAxisX(axisX, series);
                 \endcode
             */
             /*!
                 \qmlclass ValueAxis QValueAxis
                 \inherits AbstractAxis
                 \brief The ValueAxis element is used for manipulating chart's axes
                 ValueAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Values of axis are drawn to position of ticks
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         ValueAxis {
                             id: xAxis
                             min: 0
                             max: 10
                         }
                     // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QValueAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty real ValueAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \property QValueAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty real ValueAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \property QValueAxis::labelFormat
               Defines the label format for the axis.
               See QString::sprintf() for the details.
             */
             /*!
               \qmlproperty real ValueAxis::labelFormat
               Defines the label format for the axis.
               See QString::sprintf() for the details.
             */
             /*!
               \fn void QValueAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \qmlsignal ValueAxis::onMinChanged(real min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QValueAxis::maxChanged(qreal max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \qmlsignal ValueAxis::onMaxChanged(real max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QValueAxis::rangeChanged(qreal min, qreal max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
               \property QValueAxis::tickCount
               The number of tick marks for the axis.
             */
             /*!
               \qmlproperty int ValueAxis::tickCount
               The number of tick marks for the axis.
             */
             /*!
               \property QValueAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
               \qmlproperty bool ValueAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QValueAxis::QValueAxis(QObject *parent) :
                 QAbstractAxis(*new QValueAxisPrivate(this), parent)
             {
             }
             /*!
                 \internal
             */
             QValueAxis::QValueAxis(QValueAxisPrivate &d, QObject *parent)
                 : QAbstractAxis(d, parent)
             {
             }
             /*!
                 Destroys the object
             */
             QValueAxis::~QValueAxis()
             {
                 Q_D(QValueAxis);
                 if (d->m_dataset)
                     d->m_dataset->removeAxis(this);
             }
             void QValueAxis::setMin(qreal min)
             {
                 Q_D(QValueAxis);
                 setRange(min, qMax(d->m_max, min));
             }
             qreal QValueAxis::min() const
             {
                 Q_D(const QValueAxis);
                 return d->m_min;
             }
             void QValueAxis::setMax(qreal max)
             {
                 Q_D(QValueAxis);
                 setRange(qMin(d->m_min, max), max);
             }
             qreal QValueAxis::max() const
             {
                 Q_D(const QValueAxis);
                 return d->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
               If min is greater than max then this function returns without making any changes.
             */
             void QValueAxis::setRange(qreal min, qreal max)
             {
                 Q_D(QValueAxis);
                 bool changed = false;
                 if (min > max)
                     return;
                 if (d->m_niceNumbers) {
                     int ticks = d->m_tickCount;
                     d->looseNiceNumbers(min, max, ticks);
                     if (ticks != d->m_tickCount)
                         setTickCount(ticks);
                 }
-                if (!qFuzzyIsNull(d->m_min - min)) {
+                if (!qFuzzyCompare(d->m_min, min)) {
                     d->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
-                if (!qFuzzyIsNull(d->m_max - max)) {
+                if (!qFuzzyCompare(d->m_max, max)) {
                     d->m_max = max;
                     changed = true;
                     emit maxChanged(max);
                 }
                 if (changed) {
                     emit rangeChanged(min, max);
                     d->emitUpdated();
                 }
             }
             /*!
               Sets \a count for ticks on the axis.
             */
             void QValueAxis::setTickCount(int count)
             {
                 Q_D(QValueAxis);
                 if (d->m_tickCount != count && count >= 2) {
                     d->m_tickCount = count;
                     d->emitUpdated();
                 }
             }
             /*!
               \fn int QValueAxis::tickCount() const
               Return number of ticks on the axis
             */
             int QValueAxis::tickCount() const
             {
                 Q_D(const QValueAxis);
                 return d->m_tickCount;
             }
             void QValueAxis::setNiceNumbersEnabled(bool enable)
             {
                 Q_D(QValueAxis);
                 if (d->m_niceNumbers != enable) {
                     d->m_niceNumbers = enable;
-                    if (enable && !qFuzzyIsNull(d->m_max - d->m_min))
+                    if (enable && !qFuzzyCompare(d->m_max, d->m_min))
                         setRange(d->m_min, d->m_max);
                 }
             }
             bool  QValueAxis::niceNumbersEnabled() const
             {
                 Q_D(const QValueAxis);
                 return d->m_niceNumbers;
             }
             void QValueAxis::setLabelFormat(const QString &format)
             {
                 Q_D(QValueAxis);
                 d->m_format = format;
             }
             QString QValueAxis::labelFormat() const
             {
                 Q_D(const QValueAxis);
                 return d->m_format;
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QValueAxis::type() const
             {
                 return AxisTypeValue;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QValueAxisPrivate::QValueAxisPrivate(QValueAxis *q)
                 : QAbstractAxisPrivate(q),
                   m_min(0),
                   m_max(0),
                   m_tickCount(5),
                   m_niceNumbers(false),
                   m_format(QString::null)
             {
             }
             QValueAxisPrivate::~QValueAxisPrivate()
             {
             }
             void QValueAxisPrivate::handleDomainUpdated()
             {
                 Q_Q(QValueAxis);
                 Domain *domain = qobject_cast<Domain *>(sender());
                 Q_ASSERT(domain);
                 if (orientation() == Qt::Horizontal)
                     q->setRange(domain->minX(), domain->maxX());
                 else if (orientation() == Qt::Vertical)
                     q->setRange(domain->minY(), domain->maxY());
             }
             void QValueAxisPrivate::setMin(const QVariant &min)
             {
                 Q_Q(QValueAxis);
                 bool ok;
                 qreal value = min.toReal(&ok);
                 if (ok)
                     q->setMin(value);
             }
             void QValueAxisPrivate::setMax(const QVariant &max)
             {
                 Q_Q(QValueAxis);
                 bool ok;
                 qreal value = max.toReal(&ok);
                 if (ok)
                     q->setMax(value);
             }
             void QValueAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QValueAxis);
                 bool ok1;
                 bool ok2;
                 qreal value1 = min.toReal(&ok1);
                 qreal value2 = max.toReal(&ok2);
                 if (ok1 && ok2)
                     q->setRange(value1, value2);
             }
             ChartAxis *QValueAxisPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QValueAxis);
                 if (m_orientation == Qt::Vertical)
                     return new ChartValueAxisY(q, presenter);
                 return new ChartValueAxisX(q, presenter);
             }
             void QValueAxisPrivate::intializeDomain(Domain *domain)
             {
                 Q_Q(QValueAxis);
                 if (qFuzzyCompare(m_max, m_min)) {
                     if (m_orientation == Qt::Vertical)
                         q->setRange(domain->minY(), domain->maxY());
                     else
                         q->setRange(domain->minX(), domain->maxX());
                 } else {
                     if (m_orientation == Qt::Vertical)
                         domain->setRangeY(m_min, m_max);
                     else
                         domain->setRangeX(m_min, m_max);
                 }
             }
             //algorithm defined by Paul S.Heckbert GraphicalGems I
             void QValueAxisPrivate::looseNiceNumbers(qreal &min, qreal &max, int &ticksCount) const
             {
                 qreal range = niceNumber(max - min, true); //range with ceiling
                 qreal step = niceNumber(range / (ticksCount - 1), false);
                 min = qFloor(min / step);
                 max = qCeil(max / step);
                 ticksCount = int(max - min) + 1;
                 min *= step;
                 max *= step;
             }
             //nice numbers can be expressed as form of 1*10^n, 2* 10^n or 5*10^n
             qreal QValueAxisPrivate::niceNumber(qreal x, bool ceiling) const
             {
                 qreal z = qPow(10, qFloor(log10(x))); //find corresponding number of the form of 10^n than is smaller than x
                 qreal q = x / z; //q<10 && q>=1;
                 if (ceiling) {
                     if (q <= 1.0) q = 1;
                     else if (q <= 2.0) q = 2;
                     else if (q <= 5.0) q = 5;
                     else q = 10;
                 } else {
                     if (q < 1.5) q = 1;
                     else if (q < 3.0) q = 2;
                     else if (q < 7.0) q = 5;
                     else q = 10;
                 }
                 return q * z;
             }
             #include "moc_qvalueaxis.cpp"
             #include "moc_qvalueaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/bar/horizontalbarchartitem.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "horizontalbarchartitem_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset_p.h"
             #include "bar_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             HorizontalBarChartItem::HorizontalBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter)
                 : AbstractBarChartItem(series, presenter)
             {
             }
             QVector<QRectF> HorizontalBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 // On horizontal chart barWidth of the barseries means height of the rect.
                 qreal rectHeight = (scaleY / setCount) * m_series->d_func()->barWidth();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal xPos = -scaleX * m_domainMinX + geometry().left();
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal yPos = geometry().bottom() + (m_domainMinY - barSet->pos(category)) * scaleY;
                         yPos += setCount * rectHeight / 2;
                         yPos -= set * rectHeight;
                         qreal rectWidth = barSet->value(category) * scaleX;
                         Bar *bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight))
+                        if (qFuzzyCompare(rectHeight, 0))
                             bar->setVisible(false);
                         else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(barSet->value(category)))
+                        if (!qFuzzyCompare(barSet->value(category), 0))
                             label->setText(QString::number(barSet->value(category)));
                         else
                             label->setText(QString(""));
                         label->setPos(xPos + (rect.width() / 2 - label->boundingRect().width() / 2),
                                       yPos - rectHeight / 2 - label->boundingRect().height() / 2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         itemIndex++;
                     }
                 }
                 return layout;
             }
             #include "moc_horizontalbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/percent/horizontalpercentbarchartitem.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "horizontalpercentbarchartitem_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset_p.h"
             #include "bar_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             HorizontalPercentBarChartItem::HorizontalPercentBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter)
                 : AbstractBarChartItem(series, presenter)
             {
             }
             QVector<QRectF> HorizontalPercentBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal rectHeight = scaleY * m_series->d_func()->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal colSum = m_series->d_func()->categorySum(category);
                     qreal percentage = (100 / colSum);
                     qreal xPos = -scaleX * m_domainMinX + geometry().left();
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal yPos = (m_domainMinY + 0.5 - barSet->pos(category)) * scaleY + geometry().bottom() - rectHeight / 2;
                         qreal rectWidth = barSet->value(category) * percentage * scaleX;
                         Bar *bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight))
+                        if (qFuzzyCompare(rectHeight, 0))
                             bar->setVisible(false);
                         else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(m_series->d_func()->valueAt(set, category))) {
+                        if (!qFuzzyCompare(m_series->d_func()->valueAt(set, category), 0)) {
                             int p = m_series->d_func()->percentageAt(set, category) * 100;
                             QString vString(QString::number(p));
                             vString.truncate(3);
                             vString.append("%");
                             label->setText(vString);
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width() / 2 - label->boundingRect().width() / 2),
                                       yPos - rectHeight / 2 - label->boundingRect().height() / 2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         itemIndex++;
                         xPos += rectWidth;
                     }
                 }
                 return layout;
             }
             #include "moc_horizontalpercentbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/horizontal/stacked/horizontalstackedbarchartitem.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "horizontalstackedbarchartitem_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset_p.h"
             #include "bar_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             HorizontalStackedBarChartItem::HorizontalStackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter)
                 : AbstractBarChartItem(series, presenter)
             {
             }
             QVector<QRectF> HorizontalStackedBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal rectHeight = scaleY * m_series->d_func()->barWidth(); // On horizontal chart barWidth of the barseries means height of the rect.
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal xMax = -scaleX * m_domainMinX + geometry().left();
                     qreal xMin = -scaleX * m_domainMinX + geometry().left();
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal yPos = (m_domainMinY + 0.5 - barSet->pos(category)) * scaleY + geometry().bottom() - rectHeight / 2;
                         qreal rectWidth = barSet->value(category) * scaleX;
                         Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight))
+                        if (qFuzzyCompare(rectHeight, 0))
                             bar->setVisible(false);
                         else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(barSet->value(category)))
+                        if (!qFuzzyCompare(barSet->value(category), 0))
                             label->setText(QString::number(barSet->value(category)));
                         else
                             label->setText(QString(""));
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         if (rectWidth > 0) {
                             QRectF rect(xMax, yPos - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             label->setPos(xMax + (rect.width() / 2 - label->boundingRect().width() / 2),
                                           yPos - rectHeight / 2 - label->boundingRect().height() / 2);
                             xMax += rectWidth;
                         } else {
                             QRectF rect(xMin, yPos - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             label->setPos(xMin + (rect.width() / 2 - label->boundingRect().width() / 2),
                                           yPos - rectHeight / 2 - label->boundingRect().height() / 2);
                             xMin += rectWidth;
                         }
                         itemIndex++;
                     }
                 }
                 return layout;
             }
             #include "moc_horizontalstackedbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qabstractbarseries.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qabstractbarseries.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "domain_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "qvalueaxis.h"
             #include "qbarcategoryaxis.h"
             #include "qbarlegendmarker.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractBarSeries
                 \brief Series for creating a bar chart
                 \mainclass
                 QAbstractBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars to
                 the position defined by data. Single bar is defined by QPointF, where x value is the x-coordinate of the bar
                 and y-value is the height of the bar. The category names are ignored with this series and x-axis
                 shows the x-values.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \qmlclass AbstractBarSeries QAbstractBarSeries
                 \inherits QAbstractSeries
                 The following QML shows how to create a simple bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View6.qml 1
                 \beginfloatleft
                 \image demos_qmlchart6.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \property QAbstractBarSeries::barWidth
                 The width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with QBarSeries this value means the width of one group of bars instead of just one bar.
                 \sa QBarSeries
             */
             /*!
                 \qmlproperty real AbstractBarSeries::barWidth
                 The width of the bars of the series. The unit of width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with QBarSeries this value means the width of one group of bars instead of just one bar.
             */
             /*!
                 \property QAbstractBarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \qmlproperty int AbstractBarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \property QAbstractBarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \qmlproperty bool AbstractBarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \fn void QAbstractBarSeries::clicked(int index, QBarSet *barset)
                 The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \qmlsignal AbstractBarSeries::onClicked(int index, BarSet barset)
                 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 QAbstractBarSeries::hovered(bool status, QBarSet* barset)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 \qmlsignal AbstractBarSeries::onHovered(bool status, BarSet barset)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 \fn void QAbstractBarSeries::countChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \qmlsignal AbstractBarSeries::onCountChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \fn void QAbstractBarSeries::labelsVisibleChanged()
                 This signal is emitted when labels visibility have changed.
                 \sa isLabelsVisible(), setLabelsVisible()
             */
             /*!
                 \fn void QAbstractBarSeries::barsetsAdded(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal AbstractBarSeries::onBarsetsAdded(BarSet barset)
                 Emitted when \a barset has been added to the series.
             */
             /*!
                 \fn void QAbstractBarSeries::barsetsRemoved(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been removed from the series.
                 \sa remove()
             */
             /*!
                 \qmlsignal AbstractBarSeries::onBarsetsRemoved(BarSet barset)
                 Emitted when \a barset has been removed from the series.
             */
             /*!
                 \qmlmethod BarSet AbstractBarSeries::at(int index)
                 Returns bar set at \a index. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod BarSet AbstractBarSeries::append(string label, VariantList values)
                 Adds a new bar set with \a label and \a values to \a index. Values is a list of reals.
                 For example:
                 \code
                     myBarSeries.append("set 1", [0, 0.2, 0.2, 0.5, 0.4, 1.5, 0.9]);
                 \endcode
             */
             /*!
                 \qmlmethod BarSet AbstractBarSeries::insert(int index, string label, VariantList values)
                 Inserts a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XYPoints.
                 If index is zero or smaller, the new barset is prepended. If the index is count or bigger, the new barset is
                 appended.
                 \sa AbstractBarSeries::append()
             */
             /*!
                 \qmlmethod bool AbstractBarSeries::remove(BarSet barset)
                 Removes the barset from the series. Returns true if successful, false otherwise.
             */
             /*!
                 \qmlmethod AbstractBarSeries::clear()
                 Removes all barsets from the series.
             */
             /*!
                 Destructs abstractbarseries and owned barsets.
             */
             QAbstractBarSeries::~QAbstractBarSeries()
             {
             }
             /*!
                 \internal
             */
             QAbstractBarSeries::QAbstractBarSeries(QAbstractBarSeriesPrivate &o, QObject *parent)
                 : QAbstractSeries(o, parent)
             {
                 Q_D(QAbstractSeries);
                 QObject::connect(this, SIGNAL(countChanged()), d, SIGNAL(countChanged()));
             }
             /*!
                 Sets the width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with \link QBarSeries \endlink this value means the width of one group of bars instead of just one bar.
             */
             void QAbstractBarSeries::setBarWidth(qreal width)
             {
                 Q_D(QAbstractBarSeries);
                 d->setBarWidth(width);
             }
             /*!
                 Returns the width of the bars of the series.
                 \sa setBarWidth()
             */
             qreal QAbstractBarSeries::barWidth() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->barWidth();
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if appending succeeded.
             */
             bool QAbstractBarSeries::append(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->append(set);
                 if (success) {
                     QList<QBarSet *> sets;
                     sets.append(set);
                     set->setParent(this);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes barset from series. Releases ownership of \a set. Deletes the set, if remove
                 was successful.
                 Returns true, if set was removed.
             */
             bool QAbstractBarSeries::remove(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBarSet *> sets;
                     sets.append(set);
                     set->setParent(0);
                     emit barsetsRemoved(sets);
                     emit countChanged();
                     delete set;
                     set = 0;
                 }
                 return success;
             }
             /*!
                 Takes a single \a set from the series. Does not delete the barset object.
                 NOTE: The series remains as the barset's parent object. You must set the
                 parent object to take full ownership.
                 Returns true if take was successful.
             */
             bool QAbstractBarSeries::take(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBarSet *> sets;
                     sets.append(set);
                     emit barsetsRemoved(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Adds a list of barsets to series. Takes ownership of \a sets.
                 Returns true, if all sets were appended successfully. If any of the sets is null or is already appended to series,
                 nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
                 and function returns false.
             */
             bool QAbstractBarSeries::append(QList<QBarSet *> sets)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->append(sets);
                 if (success) {
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Insert a set of bars to series at \a index postion. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if inserting succeeded.
             */
             bool QAbstractBarSeries::insert(int index, QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->insert(index, set);
                 if (success) {
                     QList<QBarSet *> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes all barsets from the series. Deletes removed sets.
             */
             void QAbstractBarSeries::clear()
             {
                 Q_D(QAbstractBarSeries);
                 QList<QBarSet *> sets = barSets();
                 bool success = d->remove(sets);
                 if (success) {
                     emit barsetsRemoved(sets);
                     emit countChanged();
                     foreach (QBarSet *set, sets)
                         delete set;
                 }
             }
             /*!
                 Returns number of sets in series.
             */
             int QAbstractBarSeries::count() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet *> QAbstractBarSeries::barSets() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_barSets;
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QAbstractBarSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QAbstractBarSeries);
                 if (d->m_labelsVisible != visible) {
                     d->setLabelsVisible(visible);
                     emit labelsVisibleChanged();
                 }
             }
             /*!
                 Returns the visibility of labels
             */
             bool QAbstractBarSeries::isLabelsVisible() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_labelsVisible;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractBarSeriesPrivate::QAbstractBarSeriesPrivate(QAbstractBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barWidth(0.5),  // Default value is 50% of category width
                 m_labelsVisible(false),
                 m_visible(true)
             {
             }
             int QAbstractBarSeriesPrivate::categoryCount() const
             {
                 // No categories defined. return count of longest set.
                 int count = 0;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     if (m_barSets.at(i)->count() > count)
                         count = m_barSets.at(i)->count();
                 }
                 return count;
             }
             void QAbstractBarSeriesPrivate::setBarWidth(qreal width)
             {
                 if (width < 0.0)
                     width = 0.0;
                 m_barWidth = width;
                 emit updatedLayout();
             }
             qreal QAbstractBarSeriesPrivate::barWidth() const
             {
                 return m_barWidth;
             }
             QBarSet *QAbstractBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             void QAbstractBarSeriesPrivate::setVisible(bool visible)
             {
                 m_visible = visible;
                 emit visibleChanged();
             }
             void QAbstractBarSeriesPrivate::setLabelsVisible(bool visible)
             {
                 m_labelsVisible = visible;
                 emit labelsVisibleChanged(visible);
             }
             qreal QAbstractBarSeriesPrivate::min()
             {
                 if (m_barSets.count() <= 0)
                     return 0;
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j);
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QAbstractBarSeriesPrivate::max()
             {
                 if (m_barSets.count() <= 0)
                     return 0;
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j);
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QAbstractBarSeriesPrivate::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count()))
                     return 0; // No set, no value.
                 else if ((category < 0) || (category >= m_barSets.at(set)->count()))
                     return 0; // No category, no value.
                 return m_barSets.at(set)->at(category);
             }
             qreal QAbstractBarSeriesPrivate::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count()))
                     return 0; // No set, no value.
                 else if ((category < 0) || (category >= m_barSets.at(set)->count()))
                     return 0; // No category, no value.
                 qreal value = m_barSets.at(set)->at(category);
                 qreal sum = categorySum(category);
-                if (qFuzzyIsNull(sum))
+                if (qFuzzyCompare(sum, 0))
                     return 0;
                 return value / sum;
             }
             qreal QAbstractBarSeriesPrivate::categorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += m_barSets.at(set)->at(category);
                 }
                 return sum;
             }
             qreal QAbstractBarSeriesPrivate::absoluteCategorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += qAbs(m_barSets.at(set)->at(category));
                 }
                 return sum;
             }
             qreal QAbstractBarSeriesPrivate::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal sum = categorySum(i);
                     if (sum > max)
                         max = sum;
                 }
                 return max;
             }
             qreal QAbstractBarSeriesPrivate::minX()
             {
                 if (m_barSets.count() <= 0)
                     return 0;
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QAbstractBarSeriesPrivate::maxX()
             {
                 if (m_barSets.count() <= 0)
                     return 0;
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QAbstractBarSeriesPrivate::categoryTop(int category)
             {
                 // Returns top (sum of all positive values) of category.
                 // Returns 0, if all values are negative
                 qreal top(0);
                 int count = m_barSets.count();
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count()) {
                         qreal temp = m_barSets.at(set)->at(category);
                         if (temp > 0) {
                             top += temp;
                         }
                     }
                 }
                 return top;
             }
             qreal QAbstractBarSeriesPrivate::categoryBottom(int category)
             {
                 // Returns bottom (sum of all negative values) of category
                 // Returns 0, if all values are positive
                 qreal bottom(0);
                 int count = m_barSets.count();
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count()) {
                         qreal temp = m_barSets.at(set)->at(category);
                         if (temp < 0) {
                             bottom += temp;
                         }
                     }
                 }
                 return bottom;
             }
             qreal QAbstractBarSeriesPrivate::top()
             {
                 // Returns top of all categories
                 qreal top(0);
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal temp = categoryTop(i);
                     if (temp > top)
                         top = temp;
                 }
                 return top;
             }
             qreal QAbstractBarSeriesPrivate::bottom()
             {
                 // Returns bottom of all categories
                 qreal bottom(0);
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal temp = categoryBottom(i);
                     if (temp < bottom)
                         bottom = temp;
                 }
                 return bottom;
             }
             void QAbstractBarSeriesPrivate::scaleDomain(Domain &domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 qreal seriesMinX = this->minX();
                 qreal seriesMaxX = this->maxX();
                 qreal y = max();
                 minX = qMin(minX, seriesMinX - (qreal)0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, seriesMaxX + (qreal)0.5);
                 maxY = qMax(maxY, y);
                 domain.setRange(minX, maxX, minY, maxY);
             }
             ChartElement *QAbstractBarSeriesPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_UNUSED(presenter);
                 qWarning() << "QAbstractBarSeriesPrivate::createGraphics called";
                 return 0;
             }
             QList<QLegendMarker*> QAbstractBarSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QAbstractBarSeries);
                 QList<QLegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     QBarLegendMarker* marker = new QBarLegendMarker(q,set,legend);
                     markers << marker;
                 }
                 return markers;
             }
             bool QAbstractBarSeriesPrivate::append(QBarSet *set)
             {
                 if ((m_barSets.contains(set)) || (set == 0))
                     return false; // Fail if set is already in list or set is null.
                 m_barSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars(); // this notifies barchartitem
                 return true;
             }
             bool QAbstractBarSeriesPrivate::remove(QBarSet *set)
             {
                 if (!m_barSets.contains(set))
                     return false; // Fail if set is not in list
                 m_barSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars(); // this notifies barchartitem
                 return true;
             }
             bool QAbstractBarSeriesPrivate::append(QList<QBarSet * > sets)
             {
                 foreach (QBarSet *set, sets) {
                     if ((set == 0) || (m_barSets.contains(set)))
                         return false; // Fail if any of the sets is null or is already appended.
                     if (sets.count(set) != 1)
                         return false; // Also fail if same set is more than once in given list.
                 }
                 foreach (QBarSet *set, sets) {
                     m_barSets.append(set);
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars(); // this notifies barchartitem
                 return true;
             }
             bool QAbstractBarSeriesPrivate::remove(QList<QBarSet * > sets)
             {
                 if (sets.count() == 0)
                     return false;
                 foreach (QBarSet *set, sets) {
                     if ((set == 0) || (!m_barSets.contains(set)))
                         return false; // Fail if any of the sets is null or is not in series
                     if (sets.count(set) != 1)
                         return false; // Also fail if same set is more than once in given list.
                 }
                 foreach (QBarSet *set, sets) {
                     m_barSets.removeOne(set);
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 return true;
             }
             bool QAbstractBarSeriesPrivate::insert(int index, QBarSet *set)
             {
                 if ((m_barSets.contains(set)) || (set == 0))
                     return false; // Fail if set is already in list or set is null.
                 m_barSets.insert(index, set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();      // this notifies barchartitem
                 return true;
             }
             void QAbstractBarSeriesPrivate::initializeAxis(QAbstractAxis *axis)
             {
                 Q_Q(QAbstractBarSeries);
                 if (axis->type() == QAbstractAxis::AxisTypeBarCategory) {
                     switch (q->type()) {
                     case QAbstractSeries::SeriesTypeHorizontalBar:
                     case QAbstractSeries::SeriesTypeHorizontalPercentBar:
                     case QAbstractSeries::SeriesTypeHorizontalStackedBar:
                         if (axis->orientation() == Qt::Vertical)
                             populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
                         break;
                     case QAbstractSeries::SeriesTypeBar:
                     case QAbstractSeries::SeriesTypePercentBar:
                     case QAbstractSeries::SeriesTypeStackedBar:
                         if (axis->orientation() == Qt::Horizontal)
                             populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
                         break;
                     default:
                         qWarning() << "Unexpected series type";
                         break;
                     }
                 }
             }
             QAbstractAxis::AxisType QAbstractBarSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_Q(const QAbstractBarSeries);
                 switch (q->type()) {
                 case QAbstractSeries::SeriesTypeHorizontalBar:
                 case QAbstractSeries::SeriesTypeHorizontalPercentBar:
                 case QAbstractSeries::SeriesTypeHorizontalStackedBar:
                     if (orientation == Qt::Vertical)
                         return QAbstractAxis::AxisTypeBarCategory;
                     break;
                 case QAbstractSeries::SeriesTypeBar:
                 case QAbstractSeries::SeriesTypePercentBar:
                 case QAbstractSeries::SeriesTypeStackedBar:
                     if (orientation == Qt::Horizontal)
                         return QAbstractAxis::AxisTypeBarCategory;
                     break;
                 default:
                     qWarning() << "Unexpected series type";
                     break;
                 }
                 return QAbstractAxis::AxisTypeValue;
             }
             void QAbstractBarSeriesPrivate::populateCategories(QBarCategoryAxis *axis)
             {
                 QStringList categories;
                 if (axis->categories().isEmpty()) {
                     for (int i(1); i < categoryCount() + 1; i++)
                         categories << QString::number(i);
                     axis->append(categories);
                 }
             }
             #include "moc_qabstractbarseries.cpp"
             #include "moc_qabstractbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/bar/barchartitem.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "barchartitem_p.h"
             #include "bar_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartItem::BarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 AbstractBarChartItem(series, presenter)
             {
             }
             QVector<QRectF> BarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal rectWidth = (scaleX / setCount) * m_series->d_func()->barWidth();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal yPos = height + scaleY * m_domainMinY + geometry().top();
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->pos(category) - m_domainMinX) * scaleX + geometry().left();
                         xPos -= setCount * rectWidth / 2;
                         xPos += set * rectWidth;
                         qreal rectHeight = barSet->value(category) * scaleY;
                         Bar *bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight))
+                        if (qFuzzyCompare(rectHeight, 0))
                             bar->setVisible(false);
                         else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(barSet->value(category)))
+                        if (!qFuzzyCompare(barSet->value(category), 0))
                             label->setText(QString::number(barSet->value(category)));
                         else
                             label->setText(QString(""));
                         label->setPos(xPos + (rect.width() / 2 - label->boundingRect().width() / 2),
                                       yPos - rectHeight / 2 - label->boundingRect().height() / 2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         itemIndex++;
                     }
                 }
                 return layout;
             }
             #include "moc_barchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/percent/percentbarchartitem.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "percentbarchartitem_p.h"
             #include "bar_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarChartItem::PercentBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 AbstractBarChartItem(series, presenter)
             {
             }
             QVector<QRectF> PercentBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal rectWidth = scaleX * m_series->d_func()->barWidth();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal colSum = m_series->d_func()->categorySum(category);
                     qreal percentage = (100 / colSum);
                     qreal yPos = height + scaleY * m_domainMinY + geometry().top();
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->pos(category) - m_domainMinX) * scaleX + geometry().left() - rectWidth / 2;
                         qreal rectHeight = barSet->value(category) * percentage * scaleY;
                         Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight))
+                        if (qFuzzyCompare(rectHeight, 0))
                             bar->setVisible(false);
                         else
                             bar->setVisible(barsVisible);
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                         QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(m_series->d_func()->valueAt(set, category))) {
+                        if (!qFuzzyCompare(m_series->d_func()->valueAt(set, category), 0)) {
                             int p = m_series->d_func()->percentageAt(set, category) * 100;
                             QString vString(QString::number(p));
                             vString.truncate(3);
                             vString.append("%");
                             label->setText(vString);
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width() / 2 - label->boundingRect().width() / 2),
                                       yPos - rectHeight / 2 - label->boundingRect().height() / 2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         itemIndex++;
                         yPos -= rectHeight;
                     }
                 }
                 return layout;
             }
             #include "moc_percentbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/stacked/stackedbarchartitem.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "stackedbarchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             StackedBarChartItem::StackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 AbstractBarChartItem(series, presenter)
             {
             }
             QVector<QRectF> StackedBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal rectWidth = scaleX * m_series->d_func()->barWidth();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal yMax = height + scaleY * m_domainMinY + geometry().top();
                     qreal yMin = height + scaleY * m_domainMinY + geometry().top();
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->pos(category) - m_domainMinX) * scaleX + geometry().left() - rectWidth / 2;
                         qreal rectHeight = barSet->value(category) * scaleY;
                         Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight))
+                        if (qFuzzyCompare(rectHeight, 0))
                             bar->setVisible(false);
                         else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(barSet->value(category)))
+                        if (!qFuzzyCompare(barSet->value(category), 0))
                             label->setText(QString::number(barSet->value(category)));
                         else
                             label->setText(QString(""));
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         if (rectHeight < 0) {
                             QRectF rect(xPos, yMax - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             label->setPos(xPos + (rect.width() / 2 - label->boundingRect().width() / 2),
                                           yMax - rectHeight / 2 - label->boundingRect().height() / 2);
                             yMax -= rectHeight;
                         } else {
                             QRectF rect(xPos, yMin - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
                             label->setPos(xPos + (rect.width() / 2 - label->boundingRect().width() / 2),
                                           yMin - rectHeight / 2 - label->boundingRect().height() / 2);
                             yMin -= rectHeight;
                         }
                         itemIndex++;
                     }
                 }
                 return layout;
             }
             #include "moc_stackedbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartbackground.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartbackground_p.h"
             #include "chartconfig_p.h"
             #include <QPen>
             #include <QBrush>
             #include <QPainter>
             #include <QGraphicsDropShadowEffect>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartBackground::ChartBackground(QGraphicsItem *parent)
                 : QGraphicsRectItem(parent),
                   m_diameter(15),
                   m_dropShadow(0)
             {
             }
             ChartBackground::~ChartBackground()
             {
             }
             void ChartBackground::setDropShadowEnabled(bool enabled)
             {
                 if (enabled) {
                     if (!m_dropShadow) {
                         m_dropShadow = new QGraphicsDropShadowEffect();
             #ifdef Q_OS_MAC
                         m_dropShadow->setBlurRadius(15);
                         m_dropShadow->setOffset(0, 0);
             #elif defined(Q_OS_WIN)
                         m_dropShadow->setBlurRadius(10);
                         m_dropShadow->setOffset(0, 0);
             #else
                         m_dropShadow->setBlurRadius(10);
                         m_dropShadow->setOffset(5, 5);
             #endif
                         setGraphicsEffect(m_dropShadow);
                     }
                 } else {
                     delete m_dropShadow;
                     m_dropShadow = 0;
                 }
             }
             void ChartBackground::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
                 painter->save();
                 painter->setPen(pen());
                 painter->setBrush(brush());
                 painter->drawRoundRect(rect(), roundness(rect().width()), roundness(rect().height()));
             #ifndef QT_NO_DEBUG
                 painter->setPen(Qt::black);
                 QFont font;
                 QString build("build %1");
                 font.setPointSize(6);
                 painter->setFont(font);
                 painter->drawText(rect().bottomLeft(), build.arg(ChartConfig::instance()->compilationTime()));
             #endif
                 painter->restore();
             }
             int ChartBackground::roundness(qreal size) const
             {
-                if (qFuzzyIsNull(size))
+                if (qFuzzyCompare(size, 0))
                     return 0;
                 return 100 * m_diameter / int(size);
             }
             int ChartBackground::diameter() const
             {
                 return m_diameter;
             }
             void ChartBackground::setDiameter(int diameter)
             {
                 m_diameter = diameter;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain.cpp +7 -7

             /****************************************************************************
             **
             ** 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 "domain_p.h"
             #include "qabstractaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Domain::Domain(QObject *parent)
                 : QObject(parent),
                   m_minX(0),
                   m_maxX(0),
                   m_minY(0),
                   m_maxY(0)
             {
             }
             Domain::~Domain()
             {
             }
             void Domain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 bool axisXChanged = false;
                 bool axisYChanged = false;
-                if (!qFuzzyIsNull(m_minX - minX) || !qFuzzyIsNull(m_maxX - maxX)) {
+                if (!qFuzzyCompare(m_minX, minX) || !qFuzzyCompare(m_maxX, maxX)) {
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
                     emit rangeXChanged(m_minX, m_maxX);
                 }
-                if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
+                if (!qFuzzyCompare(m_minY, minY) || !qFuzzyCompare(m_maxY, maxY)) {
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
                     emit rangeYChanged(m_minY, m_maxY);
                 }
                 if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void Domain::setRangeX(qreal min, qreal max)
             {
                 setRange(min, max, m_minY, m_maxY);
             }
             void Domain::setRangeY(qreal min, qreal max)
             {
                 setRange(m_minX, m_maxX, min, max);
             }
             void Domain::setMinX(qreal min)
             {
                 setRange(min, m_maxX, m_minY, m_maxY);
             }
             void Domain::setMaxX(qreal max)
             {
                 setRange(m_minX, max, m_minY, m_maxY);
             }
             void Domain::setMinY(qreal min)
             {
                 setRange(m_minX, m_maxX, min, m_maxY);
             }
             void Domain::setMaxY(qreal max)
             {
                 setRange(m_minX, m_maxX, m_minY, max);
             }
             qreal Domain::spanX() const
             {
                 Q_ASSERT(m_maxX >= m_minX);
                 return m_maxX - m_minX;
             }
             qreal Domain::spanY() const
             {
                 Q_ASSERT(m_maxY >= m_minY);
                 return m_maxY - m_minY;
             }
             bool Domain::isEmpty() const
             {
-                return qFuzzyIsNull(spanX()) || qFuzzyIsNull(spanY());
+                return qFuzzyCompare(spanX(), 0) || qFuzzyCompare(spanY(), 0);
             }
             void Domain::zoomIn(const QRectF &rect, const QSizeF &size)
             {
                 qreal dx = spanX() / size.width();
                 qreal dy = spanY() / size.height();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 maxX = minX + dx * rect.right();
                 minX = minX + dx * rect.left();
                 minY = maxY - dy * rect.bottom();
                 maxY = maxY - dy * rect.top();
                 setRange(minX, maxX, minY, maxY);
             }
             void Domain::zoomOut(const QRectF &rect, const QSizeF &size)
             {
                 qreal dx = spanX() / rect.width();
                 qreal dy = spanY() / rect.height();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 minX = maxX - dx * rect.right();
                 maxX = minX + dx * size.width();
                 maxY = minY + dy * rect.bottom();
                 minY = maxY - dy * size.height();
                 setRange(minX, maxX, minY, maxY);
             }
             void Domain::move(qreal dx, qreal dy, const QSizeF &size)
             {
                 qreal x = spanX() / size.width();
                 qreal y = spanY() / size.height();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 if (dx != 0) {
                     minX = minX + x * dx;
                     maxX = maxX + x * dx;
                 }
                 if (dy != 0) {
                     minY = minY + y * dy;
                     maxY = maxY + y * dy;
                 }
                 setRange(minX, maxX, minY, maxY);
             }
             void Domain::emitUpdated()
             {
                 emit updated();
             }
             void Domain::handleAxisUpdated()
             {
                 QAbstractAxisPrivate *axis = qobject_cast<QAbstractAxisPrivate *>(sender());
                 Q_ASSERT(axis);
                 axis->setDirty(false);
                 if (axis->orientation() == Qt::Horizontal)
                     setRangeX(axis->min(), axis->max());
                 else if (axis->orientation() == Qt::Vertical)
                     setRangeY(axis->min(), axis->max());
             }
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const Domain &domain1, const Domain &domain2)
             {
-                return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
+                return (qFuzzyCompare(domain1.m_maxX, domain2.m_maxX) &&
-                        qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
+                        qFuzzyCompare(domain1.m_maxY, domain2.m_maxY) &&
-                        qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
+                        qFuzzyCompare(domain1.m_minX, domain2.m_minX) &&
-                        qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
+                        qFuzzyCompare(domain1.m_minY, domain2.m_minY));
             }
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const Domain &domain1, const Domain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const Domain &domain)
             {
                 dbg.nospace() << "Domain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')';
                 return dbg.maybeSpace();
             }
             #include "moc_domain_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.cpp +8 -8

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "qpieslice_p.h"
             #include "pieslicedata_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "qabstractaxis.h"
             #include "pieanimation_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_donut.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;
                 }
                 foreach (QPieSlice *s, slices) {
                     s->setParent(this);
                     QPieSlicePrivate::fromSlice(s)->m_series = this;
                     d->m_slices << s;
                 }
                 d->updateDerivativeData();
                 foreach(QPieSlice * s, slices) {
                     connect(s, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                     connect(s, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 }
                 emit added(slices);
                 emit countChanged();
                 return true;
             }
             /*!
                 Appends a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries &QPieSeries::operator << (QPieSlice *slice)
             {
                 append(slice);
                 return *this;
             }
             /*!
                 Appends a single slice to the series with give \a value and \a label.
                 Slice ownership is passed to the series.
             */
             QPieSlice *QPieSeries::append(QString label, qreal value)
             {
                 QPieSlice *slice = new QPieSlice(label, value);
                 append(slice);
                 return slice;
             }
             /*!
                 Inserts a single \a slice to the series before the slice at \a index position.
                 Slice ownership is passed to the series.
                 Returns true if insert was 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;
                 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 (!qFuzzyIsNull(d->m_pieRelativeHorPos - relativePosition)) {
+                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 (!qFuzzyIsNull(d->m_pieRelativeVerPos - relativePosition)) {
+                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 (qFuzzyIsNull(d->m_pieStartAngle - angle))
+                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 (qFuzzyIsNull(d->m_pieEndAngle - angle))
+                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 (!qFuzzyIsNull(m_sum - sum)) {
+                if (!qFuzzyCompare(m_sum, sum)) {
                     m_sum = sum;
                     emit q_func()->sumChanged();
                 }
                 // nothing to show..
-                if (qFuzzyIsNull(m_sum))
+                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 (!qFuzzyIsNull(m_holeRelativeSize - innerSize)) {
+                if (!qFuzzyCompare(m_holeRelativeSize, innerSize)) {
                     m_holeRelativeSize = innerSize;
                     changed = true;
                 }
-                if (!qFuzzyIsNull(m_pieRelativeSize - outerSize)) {
+                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::scaleDomain(Domain &domain)
             {
                 Q_UNUSED(domain);
                 // does not apply to pie
             }
             ChartElement *QPieSeriesPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QPieSeries);
                 PieChartItem *pie = new PieChartItem(q, presenter);
                 if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     pie->setAnimation(new PieAnimation(pie));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return pie;
             }
             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::initializeAxis(QAbstractAxis *axis)
             {
                 Q_UNUSED(axis);
             }
             QAbstractAxis::AxisType QPieSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeNoAxis;
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieslice.cpp +6 -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 "qpieslice.h"
             #include "qpieslice_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSlice
                 \brief Defines a slice in pie series.
                 This object defines the properties of a single slice in a QPieSeries.
                 In addition to the obvious value and label properties the user can also control
                 the visual appearance of a slice. By modifying the visual appearance also means that
                 the user is overriding the default appearance set by the theme.
                 Note that if the user has customized slices and theme is changed all customizations will be lost.
                 To enable user interaction with the pie some basic signals are provided about clicking and hovering.
             */
             /*!
                 \qmlclass PieSlice QPieSlice
                 PieSlice defines the properties of a single slice in a PieSeries. The element should be used
                 as a child for a PieSeries. For example:
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 2
                 An alternative (dynamic) method for adding slices to a PieSeries is using PieSeries.append
                 method.
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 4
                 In that case you may want to use PieSeries.at or PieSeries.find to access the properties of
                 an individual PieSlice instance.
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 5
                 \sa PieSeries
             */
             /*!
              \enum QPieSlice::LabelPosition
              This enum describes the position of the slice label.
              \value LabelOutside Label is outside the slice with an arm.
              \value LabelInsideHorizontal Label is centered inside the slice and laid out horizontally.
              \value LabelInsideTangential Label is centered inside the slice and rotated to be parallel to the tangential of the slice's arc.
              \value LabelInsideNormal Label is centered inside the slice rotated to be parallel to the normal of the slice's arc.
              */
             /*!
                 \property QPieSlice::label
                 Label of the slice.
                 \sa labelVisible, labelBrush, labelFont, labelArmLengthFactor
             */
             /*!
                 \qmlproperty string PieSlice::label
                 Label (text) of the slice.
             */
             /*!
                 \fn void QPieSlice::labelChanged()
                 This signal emitted when the slice label has been changed.
                 \sa label
             */
             /*!
                 \qmlsignal PieSlice::onLabelChanged()
                 This signal emitted when the slice label has been changed.
                 \sa label
             */
             /*!
                 \property QPieSlice::value
                 Value of the slice.
                 Note that if users sets a negative value it is converted to a positive value.
                 \sa percentage(), QPieSeries::sum()
             */
             /*!
                 \qmlproperty real PieSlice::value
                 Value of the slice. Note that if users sets a negative value it is converted to a positive value.
             */
             /*!
                 \fn void QPieSlice::valueChanged()
                 This signal is emitted when the slice value changes.
                 \sa value
             */
             /*!
                 \qmlsignal PieSlice::onValueChanged()
                 This signal is emitted when the slice value changes.
                 \sa value
             */
             /*!
                 \property QPieSlice::labelVisible
                 Defines the visibility of slice label. By default the label is not visible.
                 \sa label, labelBrush, labelFont, labelArmLengthFactor
             */
             /*!
                 \qmlproperty bool PieSlice::labelVisible
                 Defines the visibility of slice label. By default the label is not visible.
             */
             /*!
                 \fn void QPieSlice::labelVisibleChanged()
                 This signal emitted when visibility of the slice label has changed.
                 \sa labelVisible
             */
             /*!
                 \qmlsignal PieSlice::onLabelVisibleChanged()
                 This signal emitted when visibility of the slice label has changed.
                 \sa labelVisible
             */
             /*!
                 \property QPieSlice::exploded
                 If set to true the slice is "exploded" away from the pie.
                 \sa explodeDistanceFactor
             */
             /*!
                 \qmlproperty bool PieSlice::exploded
                 If set to true the slice is "exploded" away from the pie.
                 \sa explodeDistanceFactor
             */
             /*!
                 \property QPieSlice::pen
                 Pen used to draw the slice border.
             */
             /*!
                 \fn void QPieSlice::penChanged()
                 This signal is emitted when the pen of the slice has changed.
                 \sa pen
             */
             /*!
                 \property QPieSlice::borderColor
                 Color used to draw the slice border.
                 This is a convenience property for modifying the slice pen.
                 \sa pen, borderWidth
             */
             /*!
                 \qmlproperty color PieSlice::borderColor
                 Color used to draw the slice border (pen color).
                 \sa borderWidth
             */
             /*!
                 \fn void QPieSlice::borderColorChanged()
                 This signal is emitted when slice border color changes.
                 \sa pen, borderColor
             */
             /*!
                 \qmlsignal PieSlice::onBorderColorChanged()
                 This signal is emitted when slice border color changes.
                 \sa borderColor
             */
             /*!
                 \property QPieSlice::borderWidth
                 Width of the slice border.
                 This is a convenience property for modifying the slice pen.
                 \sa pen, borderColor
             */
             /*!
                 \qmlproperty int PieSlice::borderWidth
                 Width of the slice border.
                 This is a convenience property for modifying the slice pen.
                 \sa borderColor
             */
             /*!
                 \fn void QPieSlice::borderWidthChanged()
                 This signal is emitted when slice border width changes.
                 \sa pen, borderWidth
             */
             /*!
                 \qmlsignal PieSlice::onBorderWidthChanged()
                 This signal is emitted when slice border width changes.
                 \sa borderWidth
             */
             /*!
                 \property QPieSlice::brush
                 Brush used to draw the slice.
             */
             /*!
                 \fn void QPieSlice::brushChanged()
                 This signal is emitted when the brush of the slice has changed.
                 \sa brush
             */
             /*!
                 \property QPieSlice::color
                 Fill (brush) color of the slice.
                 This is a convenience property for modifying the slice brush.
                 \sa brush
             */
             /*!
                 \qmlproperty color PieSlice::color
                 Fill (brush) color of the slice.
             */
             /*!
                 \fn void QPieSlice::colorChanged()
                 This signal is emitted when slice color changes.
                 \sa brush
             */
             /*!
                 \qmlsignal PieSlice::onColorChanged()
                 This signal is emitted when slice color changes.
             */
             /*!
                 \property QPieSlice::labelBrush
                 Brush used to draw label and label arm of the slice.
                 \sa label, labelVisible, labelFont, labelArmLengthFactor
             */
             /*!
                 \fn void QPieSlice::labelBrushChanged()
                 This signal is emitted when the label brush of the slice has changed.
                 \sa labelBrush
             */
             /*!
                 \property QPieSlice::labelColor
                 Color used to draw the slice label.
                 This is a convenience property for modifying the slice label brush.
                 \sa labelBrush
             */
             /*!
                 \qmlproperty color PieSlice::labelColor
                 Color used to draw the slice label.
             */
             /*!
                 \fn void QPieSlice::labelColorChanged()
                 This signal is emitted when slice label color changes.
                 \sa labelColor
             */
             /*!
                 \qmlsignal PieSlice::onLabelColorChanged()
                 This signal is emitted when slice label color changes.
                 \sa labelColor
             */
             /*!
                 \property QPieSlice::labelFont
                 Font used for drawing label text.
                 \sa label, labelVisible, labelArmLengthFactor
             */
             /*!
                 \fn void QPieSlice::labelFontChanged()
                 This signal is emitted when the label font of the slice has changed.
                 \sa labelFont
             */
             /*!
                 \qmlproperty Font PieSlice::labelFont
                 Defines the font used for slice label.
                 See the \l {Font} {QML Font Element} for detailed documentation.
                 \sa labelVisible, labelPosition
             */
             /*!
                 \property QPieSlice::labelPosition
                 Position of the slice label.
                 \sa label, labelVisible
             */
             /*!
                 \qmlproperty LabelPosition PieSlice::labelPosition
                 Position of the slice label. One of PieSlice.LabelOutside, PieSlice.LabelInsideHorizontal,
                 PieSlice.LabelInsideTangential or PieSlice.LabelInsideNormal. By default the position is
                 PieSlice.LabelOutside.
                 \sa labelVisible
             */
             /*!
                 \property QPieSlice::labelArmLengthFactor
                 Defines the length of the label arm.
                 The factor is relative to pie radius. For example:
 .0 means the length is the same as the radius.
 .5 means the length is half of the radius.
                 By default the arm length is 0.15
                 \sa label, labelVisible, labelBrush, labelFont
             */
             /*!
                 \qmlproperty real PieSlice::labelArmLengthFactor
                 Defines the length of the label arm.
                 The factor is relative to pie radius. For example:
 .0 means the length is the same as the radius.
 .5 means the length is half of the radius.
                 By default the arm length is 0.15
                 \sa labelVisible
             */
             /*!
                 \property QPieSlice::explodeDistanceFactor
                 When the slice is exploded this factor defines how far the slice is exploded away from the pie.
                 The factor is relative to pie radius. For example:
 .0 means the distance is the same as the radius.
 .5 means the distance is half of the radius.
                 By default the distance is is 0.15
                 \sa exploded
             */
             /*!
                 \qmlproperty real PieSlice::explodeDistanceFactor
                 When the slice is exploded this factor defines how far the slice is exploded away from the pie.
                 The factor is relative to pie radius. For example:
 .0 means the distance is the same as the radius.
 .5 means the distance is half of the radius.
                 By default the distance is is 0.15
                 \sa exploded
             */
             /*!
                 \property QPieSlice::percentage
                 Percentage of the slice compared to the sum of all slices in the series.
                 The actual value ranges from 0.0 to 1.0.
                 Updated automatically once the slice is added to the series.
                 \sa value, QPieSeries::sum
             */
             /*!
                 \qmlproperty real PieSlice::percentage
                 Percentage of the slice compared to the sum of all slices in the series.
                 The actual value ranges from 0.0 to 1.0.
                 Updated automatically once the slice is added to the series.
             */
             /*!
                 \fn void QPieSlice::percentageChanged()
                 This signal is emitted when the percentage of the slice has changed.
                 \sa percentage
             */
             /*!
                 \qmlsignal void PieSlice::onPercentageChanged()
                 This signal is emitted when the percentage of the slice has changed.
                 \sa percentage
             */
             /*!
                 \property QPieSlice::startAngle
                 Defines the starting angle of this slice in the series it belongs to.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated automatically once the slice is added to the series.
             */
             /*!
                 \qmlproperty real PieSlice::startAngle
                 Defines the starting angle of this slice in the series it belongs to.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated automatically once the slice is added to the series.
             */
             /*!
                 \fn void QPieSlice::startAngleChanged()
                 This signal is emitted when the starting angle f the slice has changed.
                 \sa startAngle
             */
             /*!
                 \qmlsignal PieSlice::onStartAngleChanged()
                 This signal is emitted when the starting angle f the slice has changed.
                 \sa startAngle
             */
             /*!
                 \property QPieSlice::angleSpan
                 Span of the slice in degrees.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated automatically once the slice is added to the series.
             */
             /*!
                 \qmlproperty real PieSlice::angleSpan
                 Span of the slice in degrees.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated automatically once the slice is added to the series.
             */
             /*!
                 \fn void QPieSlice::angleSpanChanged()
                 This signal is emitted when the angle span of the slice has changed.
                 \sa angleSpan
             */
             /*!
                 \qmlsignal PieSlice::onAngleSpanChanged()
                 This signal is emitted when the angle span of the slice has changed.
                 \sa angleSpan
             */
             /*!
                 \fn void QPieSlice::clicked()
                 This signal is emitted when user has clicked the slice.
                 \sa QPieSeries::clicked()
             */
             /*!
                 \qmlsignal PieSlice::onClicked()
                 This signal is emitted when user has clicked the slice.
             */
             /*!
                 \fn void QPieSlice::hovered(bool state)
                 This signal is emitted when user has hovered over or away from the slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
                 \sa QPieSeries::hovered()
             */
             /*!
                 \qmlsignal PieSlice::onHovered(bool state)
                 This signal is emitted when user has hovered over or away from the slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
             */
             /*!
                 Constructs an empty slice with a \a parent.
                 \sa QPieSeries::append(), QPieSeries::insert()
             */
             QPieSlice::QPieSlice(QObject *parent)
                 : QObject(parent),
                   d_ptr(new QPieSlicePrivate(this))
             {
             }
             /*!
                 Constructs an empty slice with given \a value, \a label and a \a parent.
                 \sa QPieSeries::append(), QPieSeries::insert()
             */
             QPieSlice::QPieSlice(QString label, qreal value, QObject *parent)
                 : QObject(parent),
                   d_ptr(new QPieSlicePrivate(this))
             {
                 setValue(value);
                 setLabel(label);
             }
             /*!
                 Destroys the slice.
                 User should not delete the slice if it has been added to the series.
             */
             QPieSlice::~QPieSlice()
             {
             }
             void QPieSlice::setLabel(QString label)
             {
                 if (d_ptr->m_data.m_labelText != label) {
                     d_ptr->m_data.m_labelText = label;
                     emit labelChanged();
                 }
             }
             QString QPieSlice::label() const
             {
                 return d_ptr->m_data.m_labelText;
             }
             void QPieSlice::setValue(qreal value)
             {
                 value = qAbs(value); // negative values not allowed
-                if (!qFuzzyIsNull(d_ptr->m_data.m_value - value)) {
+                if (!qFuzzyCompare(d_ptr->m_data.m_value, value)) {
                     d_ptr->m_data.m_value = value;
                     emit valueChanged();
                 }
             }
             qreal QPieSlice::value() const
             {
                 return d_ptr->m_data.m_value;
             }
             void QPieSlice::setLabelVisible(bool visible)
             {
                 if (d_ptr->m_data.m_isLabelVisible != visible) {
                     d_ptr->m_data.m_isLabelVisible = visible;
                     emit labelVisibleChanged();
                 }
             }
             bool QPieSlice::isLabelVisible() const
             {
                 return d_ptr->m_data.m_isLabelVisible;
             }
             void QPieSlice::setExploded(bool exploded)
             {
                 if (d_ptr->m_data.m_isExploded != exploded) {
                     d_ptr->m_data.m_isExploded = exploded;
                     emit d_ptr->explodedChanged();
                 }
             }
             QPieSlice::LabelPosition QPieSlice::labelPosition()
             {
                 return d_ptr->m_data.m_labelPosition;
             }
             void QPieSlice::setLabelPosition(LabelPosition position)
             {
                 if (d_ptr->m_data.m_labelPosition != position) {
                     d_ptr->m_data.m_labelPosition = position;
                     emit d_ptr->labelPositionChanged();
                 }
             }
             bool QPieSlice::isExploded() const
             {
                 return d_ptr->m_data.m_isExploded;
             }
             void QPieSlice::setPen(const QPen &pen)
             {
                 d_ptr->setPen(pen, false);
             }
             QPen QPieSlice::pen() const
             {
                 return d_ptr->m_data.m_slicePen;
             }
             QColor QPieSlice::borderColor()
             {
                 return pen().color();
             }
             void QPieSlice::setBorderColor(QColor color)
             {
                 QPen p = pen();
                 if (color != p.color()) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             int QPieSlice::borderWidth()
             {
                 return pen().width();
             }
             void QPieSlice::setBorderWidth(int width)
             {
                 QPen p = pen();
                 if (width != p.width()) {
                     p.setWidth(width);
                     setPen(p);
                 }
             }
             void QPieSlice::setBrush(const QBrush &brush)
             {
                 d_ptr->setBrush(brush, false);
             }
             QBrush QPieSlice::brush() const
             {
                 return d_ptr->m_data.m_sliceBrush;
             }
             QColor QPieSlice::color()
             {
                 return brush().color();
             }
             void QPieSlice::setColor(QColor color)
             {
                 QBrush b = brush();
                 if (b == QBrush())
                     b.setStyle(Qt::SolidPattern);
                 b.setColor(color);
                 setBrush(b);
             }
             void QPieSlice::setLabelBrush(const QBrush &brush)
             {
                 d_ptr->setLabelBrush(brush, false);
             }
             QBrush QPieSlice::labelBrush() const
             {
                 return d_ptr->m_data.m_labelBrush;
             }
             QColor QPieSlice::labelColor()
             {
                 return labelBrush().color();
             }
             void QPieSlice::setLabelColor(QColor color)
             {
                 QBrush b = labelBrush();
                 if (color != b.color()) {
                     b.setColor(color);
                     setLabelBrush(b);
                 }
             }
             void QPieSlice::setLabelFont(const QFont &font)
             {
                 d_ptr->setLabelFont(font, false);
             }
             QFont QPieSlice::labelFont() const
             {
                 return d_ptr->m_data.m_labelFont;
             }
             void QPieSlice::setLabelArmLengthFactor(qreal factor)
             {
-                if (!qFuzzyIsNull(d_ptr->m_data.m_labelArmLengthFactor - factor)) {
+                if (!qFuzzyCompare(d_ptr->m_data.m_labelArmLengthFactor, factor)) {
                     d_ptr->m_data.m_labelArmLengthFactor = factor;
                     emit d_ptr->labelArmLengthFactorChanged();
                 }
             }
             qreal QPieSlice::labelArmLengthFactor() const
             {
                 return d_ptr->m_data.m_labelArmLengthFactor;
             }
             void QPieSlice::setExplodeDistanceFactor(qreal factor)
             {
-                if (!qFuzzyIsNull(d_ptr->m_data.m_explodeDistanceFactor - factor)) {
+                if (!qFuzzyCompare(d_ptr->m_data.m_explodeDistanceFactor, factor)) {
                     d_ptr->m_data.m_explodeDistanceFactor = factor;
                     emit d_ptr->explodeDistanceFactorChanged();
                 }
             }
             qreal QPieSlice::explodeDistanceFactor() const
             {
                 return d_ptr->m_data.m_explodeDistanceFactor;
             }
             qreal QPieSlice::percentage() const
             {
                 return d_ptr->m_data.m_percentage;
             }
             qreal QPieSlice::startAngle() const
             {
                 return d_ptr->m_data.m_startAngle;
             }
             qreal QPieSlice::angleSpan() const
             {
                 return d_ptr->m_data.m_angleSpan;
             }
             /*!
               Returns the series that this slice belongs to.
               \sa QPieSeries::append()
             */
             QPieSeries *QPieSlice::series() const
             {
                 return d_ptr->m_series;
             }
             QPieSlicePrivate::QPieSlicePrivate(QPieSlice *parent)
                 : QObject(parent),
                   q_ptr(parent),
                   m_series(0)
             {
             }
             QPieSlicePrivate::~QPieSlicePrivate()
             {
             }
             QPieSlicePrivate *QPieSlicePrivate::fromSlice(QPieSlice *slice)
             {
                 return slice->d_func();
             }
             void QPieSlicePrivate::setPen(const QPen &pen, bool themed)
             {
                 if (m_data.m_slicePen != pen) {
                     QPen oldPen = m_data.m_slicePen;
                     m_data.m_slicePen = pen;
                     m_data.m_slicePen.setThemed(themed);
                     emit q_ptr->penChanged();
                     if (oldPen.color() != pen.color())
                         emit q_ptr->borderColorChanged();
                     if (oldPen.width() != pen.width())
                         emit q_ptr->borderWidthChanged();
                 }
             }
             void QPieSlicePrivate::setBrush(const QBrush &brush, bool themed)
             {
                 if (m_data.m_sliceBrush != brush) {
                     QBrush oldBrush = m_data.m_sliceBrush;
                     m_data.m_sliceBrush = brush;
                     m_data.m_sliceBrush.setThemed(themed);
                     emit q_ptr->brushChanged();
                     if (oldBrush.color() != brush.color())
                         emit q_ptr->colorChanged();
                 }
             }
             void QPieSlicePrivate::setLabelBrush(const QBrush &brush, bool themed)
             {
                 if (m_data.m_labelBrush != brush) {
                     QBrush oldBrush = m_data.m_labelBrush;
                     m_data.m_labelBrush = brush;
                     m_data.m_labelBrush.setThemed(themed);
                     emit q_ptr->labelBrushChanged();
                     if (oldBrush.color() != brush.color())
                         emit q_ptr->labelColorChanged();
                 }
             }
             void QPieSlicePrivate::setLabelFont(const QFont &font, bool themed)
             {
                 if (m_data.m_labelFont != font) {
                     m_data.m_labelFont = font;
                     m_data.m_labelFont.setThemed(themed);
                     emit q_ptr->labelFontChanged();
                 }
             }
             void QPieSlicePrivate::setPercentage(qreal percentage)
             {
-                if (!qFuzzyIsNull(m_data.m_percentage - percentage)) {
+                if (!qFuzzyCompare(m_data.m_percentage, percentage)) {
                     m_data.m_percentage = percentage;
                     emit q_ptr->percentageChanged();
                 }
             }
             void QPieSlicePrivate::setStartAngle(qreal angle)
             {
-                if (!qFuzzyIsNull(m_data.m_startAngle - angle)) {
+                if (!qFuzzyCompare(m_data.m_startAngle, angle)) {
                     m_data.m_startAngle = angle;
                     emit q_ptr->startAngleChanged();
                 }
             }
             void QPieSlicePrivate::setAngleSpan(qreal span)
             {
-                if (!qFuzzyIsNull(m_data.m_angleSpan - span)) {
+                if (!qFuzzyCompare(m_data.m_angleSpan, span)) {
                     m_data.m_angleSpan = span;
                     emit q_ptr->angleSpanChanged();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             #include "moc_qpieslice.cpp"
             #include "moc_qpieslice_p.cpp"

src/qchart.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qchart.h"
             #include "qchart_p.h"
             #include "legendscroller_p.h"
             #include "qlegend_p.h"
             #include "chartbackground_p.h"
             #include "qabstractaxis.h"
             #include "chartlayout_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              \enum QChart::ChartTheme
              This enum describes the theme used by the chart.
              \value ChartThemeLight The default theme
              \value ChartThemeBlueCerulean
              \value ChartThemeDark
              \value ChartThemeBrownSand
              \value ChartThemeBlueNcs
              \value ChartThemeHighContrast
              \value ChartThemeBlueIcy
              */
             /*!
              \enum QChart::AnimationOption
              For enabling/disabling animations. Defaults to NoAnimation.
              \value NoAnimation
              \value GridAxisAnimations
              \value SeriesAnimations
              \value AllAnimations
              */
             /*!
              \class QChart
              \brief QtCommercial chart API.
              QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
              representation of different types of series and other chart related objects like
              QAxis and QLegend. If you simply want to show a chart in a layout, you can use the
              convenience class QChartView instead of QChart.
              \sa QChartView
              */
             /*!
              \property QChart::animationOptions
              The animation \a options for the chart. Animations are enabled/disabled based on this setting.
              */
             /*!
              \property QChart::backgroundVisible
              Whether the chart background is visible or not.
              \sa setBackgroundBrush(), setBackgroundPen()
              */
             /*!
              \property QChart::dropShadowEnabled
              If set to true, the background drop shadow effect is enabled. If set to false, it is disabled. Note that the drop
              shadow effect depends on theme, which means the setting may be changed if you switch to another theme.
              */
             /*!
              \property QChart::minimumMargins
              Minimum margins between the plot area (axes) and the edge of the chart widget.
              */
             /*!
              \property QChart::theme
              Theme is a built-in collection of UI style related settings applied for all visual elements of a chart, like colors,
              pens, brushes and fonts of series, axes, title and legend. \l {Chart themes demo} shows an example with a few
              different themes.
              Note: changing the theme will overwrite all customizations previously applied to the series.
              */
             /*!
              \property QChart::title
              Title is the name (label) of a chart. It is shown as a headline on top of the chart.
              */
             /*!
              Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 : QGraphicsWidget(parent, wFlags),
                   d_ptr(new QChartPrivate())
             {
                 d_ptr->m_dataset = new ChartDataSet(this);
                 d_ptr->m_presenter = new ChartPresenter(this, d_ptr->m_dataset);
                 d_ptr->createConnections();
                 d_ptr->m_legend = new LegendScroller(this);
                 d_ptr->m_presenter->setTheme(QChart::ChartThemeLight, false);
                 //connect(d_ptr->m_presenter, SIGNAL(marginsChanged(QRectF)), this, SIGNAL(marginsChanged(QRectF)));
                 setLayout(d_ptr->m_presenter->layout());
             }
             /*!
              Destroys the object and it's children, like series and axis objects added to it.
              */
             QChart::~QChart()
             {
                 //delete first presenter , since this is a root of all the graphical items
                 setLayout(0);
                 delete d_ptr->m_presenter;
                 d_ptr->m_presenter = 0;
             }
             /*!
              Adds the \a series onto the chart and takes the ownership of the object.
              If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
              the y axis).
              \sa removeSeries(), removeAllSeries()
              */
             void QChart::addSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->addSeries(series);
             }
             /*!
              Removes the \a series specified in a perameter from the QChartView.
              It releses its ownership of the specified QChartSeries object.
              It does not delete the pointed QChartSeries data object
              \sa addSeries(), removeAllSeries()
              */
             void QChart::removeSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->removeSeries(series);
             }
             /*!
              Removes all the QChartSeries that have been added to the QChartView
              It also deletes the pointed QChartSeries data objects
              \sa addSeries(), removeSeries()
              */
             void QChart::removeAllSeries()
             {
                 d_ptr->m_dataset->removeAllSeries();
             }
             /*!
              Sets the \a brush that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setBackgroundBrush(brush);
             }
             /*!
                 Gets the brush that is used for painting the background of the chart area.
              */
             QBrush QChart::backgroundBrush() const
             {
                 return d_ptr->m_presenter->backgroundBrush();
             }
             /*!
              Sets the \a pen that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundPen(const QPen &pen)
             {
                 d_ptr->m_presenter->setBackgroundPen(pen);
             }
             /*!
                 Gets the pen that is used for painting the background of the chart area.
              */
             QPen QChart::backgroundPen() const
             {
                 return d_ptr->m_presenter->backgroundPen();
             }
             /*!
              Sets the chart \a title. The description text that is drawn above the chart.
              */
             void QChart::setTitle(const QString &title)
             {
                 d_ptr->m_presenter->setTitle(title);
             }
             /*!
              Returns the chart title. The description text that is drawn above the chart.
              */
             QString QChart::title() const
             {
                 return d_ptr->m_presenter->title();
             }
             /*!
              Sets the \a font that is used for drawing the chart description text that is rendered above the chart.
              */
             void QChart::setTitleFont(const QFont &font)
             {
                 d_ptr->m_presenter->setTitleFont(font);
             }
             /*!
                 Gets the font that is used for drawing the chart description text that is rendered above the chart.
              */
             QFont QChart::titleFont() const
             {
                 return d_ptr->m_presenter->titleFont();
             }
             /*!
              Sets the \a brush used for rendering the title text.
              */
             void QChart::setTitleBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setTitleBrush(brush);
             }
             /*!
              Returns the brush used for rendering the title text.
              */
             QBrush QChart::titleBrush() const
             {
                 return d_ptr->m_presenter->titleBrush();
             }
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 d_ptr->m_presenter->setTheme(theme);
             }
             QChart::ChartTheme QChart::theme() const
             {
                 return d_ptr->m_presenter->theme();
             }
             /*!
              Zooms in the view by a factor of 2
              */
             void QChart::zoomIn()
             {
                 d_ptr->m_presenter->zoomIn(2.0);
             }
             /*!
              Zooms in the view to a maximum level at which \a rect is still fully visible.
              */
             void QChart::zoomIn(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
                 d_ptr->m_presenter->zoomIn(rect);
             }
             /*!
              Restores the view zoom level to the previous one.
              */
             void QChart::zoomOut()
             {
                 d_ptr->m_presenter->zoomOut(2.0);
             }
             /*!
              Zooms in the view by a \a factor.
              A factor over 1.0 zooms the view in and factor between 0.0 and 1.0 zooms out.
              */
             void QChart::zoom(qreal factor)
             {
-                if (qFuzzyIsNull(factor))
+                if (qFuzzyCompare(factor, 0))
                     return;
                 if (qFuzzyCompare(factor, (qreal)1.0))
                     return;
                 if (factor < 0)
                     return;
                 if (factor > 1.0)
                     d_ptr->m_presenter->zoomIn(factor);
                 else
                     d_ptr->m_presenter->zoomOut(1.0 / factor);
             }
             /*!
              Returns the pointer to the x axis object of the chart asociated with the specified \a series
              If no series is provided then pointer to currently visible axis is provided
              */
             QAbstractAxis *QChart::axisX(QAbstractSeries *series) const
             {
                 return d_ptr->m_dataset->axisX(series);
             }
             /*!
              Returns the pointer to the y axis object of the chart asociated with the specified \a series
              If no series is provided then pointer to currently visible axis is provided
              */
             QAbstractAxis *QChart::axisY(QAbstractSeries *series) const
             {
                 return d_ptr->m_dataset->axisY(series);
             }
             /*!
              NOTICE: This function has to be called after series has been added to the chart if no customized axes are set to the chart. Otherwise axisX(), axisY() calls return NULL.
              Creates the axes for the chart based on the series that has already been added to the chart.
             \table
                  \header
                      \o Series type
                      \o X-axis
                      \o Y-axis
                  \row
                      \o QXYSeries
                      \o QValueAxis
                      \o QValueAxis
                  \row
                      \o QBarSeries
                      \o QBarCategoryAxis
                      \o QValueAxis
                  \row
                      \o QPieSeries
                      \o None
                      \o None
                  \endtable
              If there are several QXYSeries derived series added to the chart and no other series type has been added then only one pair of axes is created.
              If there are sevaral series added of different types then each series gets its own axes pair.
              NOTICE: if there is more than one x and y axes created then no axis is drawn by default and one needs to choose explicitly which axis should be shown.
              Axis specifix to the series can be later obtained from the chart by providing the series as the parameter of axisX(), axisY() function calls.
              QPieSeries does not create any axes.
              \sa axisX(), axisY(), setAxisX(), setAxisY()
              */
             void QChart::createDefaultAxes()
             {
                 d_ptr->m_dataset->createDefaultAxes();
             }
             /*!
              Returns the legend object of the chart. Ownership stays in chart.
              */
             QLegend *QChart::legend() const
             {
                 return d_ptr->m_legend;
             }
             /*!
               Sets the minimum \a margins between the plot area (axes) and the edge of the chart widget.
             */
             void QChart::setMargins(const QMargins &margins)
             {
                 d_ptr->m_presenter->layout()->setMargins(margins);
             }
             /*!
                 Returns the rect that contains information about margins (distance between chart widget edge and axes).
                 Individual margins can be obtained by calling left, top, right, bottom on the returned rect.
              */
             QMargins QChart::margins() const
             {
                 return d_ptr->m_presenter->layout()->margins();
             }
             /*!
                 Returns the the rect within which the drawing of the chart is done.
                 It does not include the area defines by margins.
              */
             QRectF QChart::plotArea() const
             {
                 return d_ptr->m_presenter->layout()->chartsGeometry();
             }
             ///*!
             //    TODO: Dummy.
             //    Adjest the ranges of the axes so that all the data of the specified \a series is visible
             // */
             //void QChart::adjustViewToSeries(QAbstractSeries* series)
             //{
             //    //
             //}
             /*!
              Sets animation \a options for the chart
              */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 d_ptr->m_presenter->setAnimationOptions(options);
             }
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return d_ptr->m_presenter->animationOptions();
             }
             /*!
                 Scrolls the visible area of the chart by the distance defined in the \a dx and \a dy.
              */
             void QChart::scroll(qreal dx, qreal dy)
             {
                 d_ptr->m_presenter->scroll(dx, dy);
             }
             void QChart::setBackgroundVisible(bool visible)
             {
                 d_ptr->m_presenter->setBackgroundVisible(visible);
             }
             bool QChart::isBackgroundVisible() const
             {
                 return d_ptr->m_presenter->isBackgroundVisible();
             }
             void QChart::setDropShadowEnabled(bool enabled)
             {
                 d_ptr->m_presenter->setBackgroundDropShadowEnabled(enabled);
             }
             bool QChart::isDropShadowEnabled() const
             {
                 return d_ptr->m_presenter->isBackgroundDropShadowEnabled();
             }
             /*!
               Returns all the series that are added to the chart.
               \sa addSeries(), removeSeries(), removeAllSeries()
             */
             QList<QAbstractSeries *> QChart::series() const
             {
                 return d_ptr->m_dataset->series();
             }
             /*!
               Sets \a axis to the chart, which will control the presentation of the \a series
                \sa axisX(), axisY(), setAxisY(), createDefaultAxes()
             */
             void QChart::setAxisX(QAbstractAxis *axis , QAbstractSeries *series)
             {
                 if (axis->alignment() == Qt::AlignLeft || axis->alignment() == Qt::AlignRight)
                     return;
                 d_ptr->m_dataset->setAxis(series, axis, Qt::Horizontal);
             }
             /*!
               Sets \a axis to the chart, which will control the presentation of the \a series
                \sa axisX(), axisY(), setAxisX(), createDefaultAxes()
             */
             void QChart::setAxisY(QAbstractAxis *axis , QAbstractSeries *series)
             {
                 if (axis->alignment() == Qt::AlignTop || axis->alignment() == Qt::AlignBottom)
                     return;
                 d_ptr->m_dataset->setAxis(series, axis, Qt::Vertical);
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartPrivate::QChartPrivate():
                 m_legend(0),
                 m_dataset(0),
                 m_presenter(0)
             {
             }
             QChartPrivate::~QChartPrivate()
             {
             }
             void QChartPrivate::createConnections()
             {
                 QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*,Domain*)), m_presenter, SLOT(handleSeriesAdded(QAbstractSeries*,Domain*)));
                 QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), m_presenter, SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)), m_presenter, SLOT(handleAxisAdded(QAbstractAxis*,Domain*)));
                 QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)), m_presenter, SLOT(handleAxisRemoved(QAbstractAxis*)));
                 //QObject::connect(m_presenter, SIGNAL(marginsChanged(QRectF)), q_ptr, SIGNAL(marginsChanged(QRectF)));
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterchart/qscatterseries.cpp +1 -1

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

src/scroller.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "scroller_p.h"
             #include "qlegend.h"
             #include <QGraphicsSceneMouseEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Scroller::Scroller()
                 : m_ticker(this),
                   m_timeTresholdMin(50),
                   m_timeTresholdMax(300),
                   m_state(Idle),
                   m_treshold(10)
             {
             }
             Scroller::~Scroller()
             {
             }
             void Scroller::move(const QPointF &delta)
             {
                 switch (m_state) {
                 case Pressed:
                     m_timeStamp = QTime::currentTime();
                     break;
                 case Scroll:
                     stopTicker();
                     m_timeStamp = QTime::currentTime();
                     break;
                 default:
                     break;
                 }
                 setOffset(offset() - delta);
             }
             void Scroller::scrollTo(const QPointF &delta)
             {
                 // Starts scrolling, if at least m_timeTresholdMin msecs has gone since timestamp
                 // current time is no more than m_timeTresholdMax from timestamp
                 if ((m_timeStamp.elapsed() > m_timeTresholdMin) && (m_timeStamp.msecsTo(QTime::currentTime()) < m_timeTresholdMax)) {
                     // Release was quick enough. Start scrolling.
                     qreal interval = 25;
                     qreal time = m_timeStamp.msecsTo(QTime::currentTime());
-                    if (qFuzzyIsNull(time)) {
+                    if (qFuzzyCompare(time, 0)) {
                         m_speed = delta / 5;
                     } else {
                         m_speed = delta * interval / time;
                     }
                     qreal fraction = qMax(qAbs(m_speed.x()), qAbs(m_speed.y()));
-                    if (!qFuzzyIsNull(fraction)) {
+                    if (!qFuzzyCompare(fraction, 0)) {
                         m_fraction.setX(qAbs(m_speed.x() / fraction));
                         m_fraction.setY(qAbs(m_speed.y() / fraction));
                     } else {
                         m_fraction.setX(1);
                         m_fraction.setY(1);
                     }
                     startTicker(interval);
                 } else {
                     stopTicker();   // Stop ticker, if one is running.
                 }
             }
             void Scroller::handleMousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 stopTicker();
                 m_pressPos = event->screenPos();
                 m_lastPos = m_pressPos;
                 m_state = Pressed;
                 event->accept();
             }
             void Scroller::handleMouseMoveEvent(QGraphicsSceneMouseEvent *event)
             {
                 QPointF delta = event->screenPos() - m_lastPos;
                 switch (m_state) {
                 case Pressed: {
                     // calculate treshold. If enough, change to move state and send out move deltas.
                     if (qAbs(delta.x()) > m_treshold || qAbs(delta.y()) > m_treshold) {
                         m_lastPos = event->screenPos();
                         move(delta);
                         m_state = Move;
                     }
                     event->accept();
                     break;
                 }
                 case Move: {
                     m_lastPos = event->screenPos();
                     move(delta);
                     event->accept();
                     break;
                 }
                 case Idle:
                 default: {
                     event->ignore();
                     break;
                 }
                 }
             }
             void Scroller::handleMouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
                 switch (m_state) {
                 case Move:
                 {
                     scrollTo(m_lastPos - m_pressPos);
                     event->accept();
                     break;
                 }
                 default:
                 {
                     m_state = Idle;
                     event->ignore();
                     break;
                 }
                 }
             }
             void Scroller::startTicker(int interval)
             {
                 m_state = Scroll;
                 m_ticker.start(interval);
             }
             void Scroller::stopTicker()
             {
                 m_state = Idle;
                 m_ticker.stop();
             }
             void Scroller::scrollTick()
             {
                 switch (m_state) {
                 case Scroll:
                     lowerSpeed(m_speed);
                     setOffset(offset() - m_speed);
                     if (m_speed == QPointF(0, 0)) {
                         m_state = Idle;
                         m_ticker.stop();
                     }
                     break;
                 default:
                     qWarning() << __FUNCTION__ << "Scroller unexpected state" << m_state;
                     m_ticker.stop();
                     m_state = Idle;
                     break;
                 }
             }
             void Scroller::lowerSpeed(QPointF &speed, qreal maxSpeed)
             {
                 qreal x = qBound(-maxSpeed, speed.x(), maxSpeed);
                 qreal y = qBound(-maxSpeed, speed.y(), maxSpeed);
                 x = (x == 0) ? x :
                     (x > 0) ? qMax(qreal(0), x - m_fraction.x()) : qMin(qreal(0), x + m_fraction.x());
                 y = (y == 0) ? y :
                     (y > 0) ? qMax(qreal(0), y - m_fraction.y()) : qMin(qreal(0), y + m_fraction.y());
                 speed.setX(x);
                 speed.setY(y);
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             ScrollTicker::ScrollTicker(Scroller *scroller, QObject *parent)
                 : QObject(parent),
                   m_scroller(scroller)
             {
             }
             void ScrollTicker::start(int interval)
             {
                 if (!m_timer.isActive())
                     m_timer.start(interval, this);
             }
             void ScrollTicker::stop()
             {
                 m_timer.stop();
             }
             void ScrollTicker::timerEvent(QTimerEvent *event)
             {
                 Q_UNUSED(event);
                 m_scroller->scrollTick();
             }
             #include "moc_scroller_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/xychart.cpp +1 -1

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "xychart_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "chartpresenter_p.h"
             #include "domain_p.h"
             #include "qxymodelmapper.h"
             #include <QPainter>
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             XYChart::XYChart(QXYSeries *series, ChartPresenter *presenter)
                 : ChartElement(presenter),
                   m_minX(0),
                   m_maxX(0),
                   m_minY(0),
                   m_maxY(0),
                   m_series(series),
                   m_animation(0),
                   m_dirty(true)
             {
                 QObject::connect(series, SIGNAL(pointReplaced(int)), this, SLOT(handlePointReplaced(int)));
                 QObject::connect(series, SIGNAL(pointsReplaced()), this, SLOT(handlePointsReplaced()));
                 QObject::connect(series, SIGNAL(pointAdded(int)), this, SLOT(handlePointAdded(int)));
                 QObject::connect(series, SIGNAL(pointRemoved(int)), this, SLOT(handlePointRemoved(int)));
                 QObject::connect(this, SIGNAL(clicked(QPointF)), series, SIGNAL(clicked(QPointF)));
             }
             void XYChart::setGeometryPoints(const QVector<QPointF>& points)
             {
                 m_points = points;
             }
             void XYChart::setClipRect(const QRectF &rect)
             {
                 m_clipRect = rect;
             }
             void XYChart::setAnimation(XYAnimation *animation)
             {
                 m_animation = animation;
             }
             void XYChart::setDirty(bool dirty)
             {
                 m_dirty = dirty;
             }
             QPointF XYChart::calculateGeometryPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 qreal x = (point.x() - m_minX) * deltaX;
                 qreal y = (point.y() - m_minY) * -deltaY + m_size.height();
                 return QPointF(x, y);
             }
             QPointF XYChart::calculateGeometryPoint(int index) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 const QList<QPointF>& vector = m_series->points();
                 qreal x = (vector[index].x() - m_minX) * deltaX;
                 qreal y = (vector[index].y() - m_minY) * -deltaY + m_size.height();
                 return QPointF(x, y);
             }
             QVector<QPointF> XYChart::calculateGeometryPoints() const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 QVector<QPointF> result;
                 result.resize(m_series->count());
                 const QList<QPointF>& vector = m_series->points();
                 for (int i = 0; i < m_series->count(); ++i) {
                     qreal x = (vector[i].x() - m_minX) * deltaX;
                     qreal y = (vector[i].y() - m_minY) * -deltaY + m_size.height();
                     result[i].setX(x);
                     result[i].setY(y);
                 }
                 return result;
             }
             QPointF XYChart::calculateDomainPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 qreal x = point.x() / deltaX + m_minX;
                 qreal y = (point.y() - m_size.height()) / (-deltaY) + m_minY;
                 return QPointF(x, y);
             }
             void XYChart::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
             {
                 if (m_animation) {
                     m_animation->setup(oldPoints, newPoints, index);
                     m_points = newPoints;
                     setDirty(false);
                     presenter()->startAnimation(m_animation);
                 } else {
                     m_points = newPoints;
                     updateGeometry();
                 }
             }
             //handlers
             void XYChart::handlePointAdded(int index)
             {
                 Q_ASSERT(index < m_series->count());
                 Q_ASSERT(index >= 0);
                 QVector<QPointF> points;
                 if (m_dirty) {
                     points = calculateGeometryPoints();
                 } else {
                     points = m_points;
                     QPointF point = calculateGeometryPoint(index);
                     points.insert(index, point);
                 }
                 updateChart(m_points, points, index);
             }
             void XYChart::handlePointRemoved(int index)
             {
                 Q_ASSERT(index <= m_series->count());
                 Q_ASSERT(index >= 0);
                 QVector<QPointF> points;
                 if (m_dirty) {
                     points = calculateGeometryPoints();
                 } else {
                     points = m_points;
                     points.remove(index);
                 }
                 updateChart(m_points, points, index);
             }
             void XYChart::handlePointReplaced(int index)
             {
                 Q_ASSERT(index < m_series->count());
                 Q_ASSERT(index >= 0);
                 QVector<QPointF> points;
                 if (m_dirty) {
                     points = calculateGeometryPoints();
                 } else {
                     QPointF point = calculateGeometryPoint(index);
                     points = m_points;
                     points.replace(index, point);
                 }
                 updateChart(m_points, points, index);
             }
             void XYChart::handlePointsReplaced()
             {
                 // All the points were replaced -> recalculate
                 QVector<QPointF> points = calculateGeometryPoints();
                 updateChart(m_points, points, -1);
             }
             void XYChart::handleDomainUpdated()
             {
                 m_minX = domain()->minX();
                 m_maxX = domain()->maxX();
                 m_minY = domain()->minY();
                 m_maxY = domain()->maxY();
                 if (isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 updateChart(m_points, points);
             }
             void XYChart::handleGeometryChanged(const QRectF &rect)
             {
                 Q_ASSERT(rect.isValid());
                 m_size = rect.size();
                 m_clipRect = rect.translated(-rect.topLeft());
                 m_origin = rect.topLeft();
                 if (isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 updateChart(m_points, points);
             }
             bool XYChart::isEmpty()
             {
-                return !m_clipRect.isValid() || qFuzzyIsNull(m_maxX - m_minX) || qFuzzyIsNull(m_maxY - m_minY) || m_series->points().isEmpty();
+                return !m_clipRect.isValid() || qFuzzyCompare(m_maxX, m_minX) || qFuzzyCompare(m_maxY, m_minY) || m_series->points().isEmpty();
             }
             #include "moc_xychart_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/auto/domain/tst_domain.cpp +16 -16

             /****************************************************************************
             **
             ** 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 BUILD_PRIVATE_UNIT_TESTS
             #include <QtTest/QtTest>
             class tst_Domain: public QObject {
                 Q_OBJECT
             private Q_SLOTS:
                 void skip();
             };
             void tst_Domain::skip()
             {
             #ifdef QT5_QUICK_1
                 QSKIP("This test requires the debug version of library");
             #else
                 QSKIP("This test requires the debug version of library", SkipAll);
             #endif
             }
             QTEST_MAIN(tst_Domain)
             #include "tst_domain.moc"
             #else
             #include <QtTest/QtTest>
             #include <private/domain_p.h>
             #include <private/qabstractaxis_p.h>
             #include <tst_definitions.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(Domain*)
             Q_DECLARE_METATYPE(QSizeF)
             class AxisMock: public QAbstractAxisPrivate
             {
             Q_OBJECT
             public:
                 AxisMock(Qt::Orientation orientation):QAbstractAxisPrivate(0){ setOrientation(orientation);};
                 ChartAxis* createGraphics(ChartPresenter* presenter)
                 {
                     Q_UNUSED(presenter);
                     return 0;
                 };
                 void intializeDomain(Domain* domain)
                 {
                     Q_UNUSED(domain);
                 };
                 void setMin(const QVariant &min)
                 {
                     Q_UNUSED(min);
                 }
                 qreal min() { return m_min;}
                 void setMax(const QVariant &max)
                 {
                     Q_UNUSED(max);
                 }
                 qreal max() { return m_max; }
                 void setRange(const QVariant &min, const QVariant &max)
                 {
                     Q_UNUSED(min);
                     Q_UNUSED(max);
                 };
                 int count () const { return m_count; }
                 void handleDomainUpdated(){};
             public:
                 int m_count;
                 qreal m_min;
                 qreal m_max;
             };
             class tst_Domain: public QObject
             {
             Q_OBJECT
             public Q_SLOTS:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private Q_SLOTS:
                 void domain();
                 void handleAxisUpdatedX_data();
                 void handleAxisUpdatedX();
                 void handleAxisUpdatedY_data();
                 void handleAxisUpdatedY();
                 void isEmpty_data();
                 void isEmpty();
                 void maxX_data();
                 void maxX();
                 void maxY_data();
                 void maxY();
                 void minX_data();
                 void minX();
                 void minY_data();
                 void minY();
                 void operatorEquals_data();
                 void operatorEquals();
                 void setRange_data();
                 void setRange();
                 void setRangeX_data();
                 void setRangeX();
                 void setRangeY_data();
                 void setRangeY();
                 void spanX_data();
                 void spanX();
                 void spanY_data();
                 void spanY();
                 void zoom_data();
                 void zoom();
                 void move_data();
                 void move();
             };
             void tst_Domain::initTestCase()
             {
             }
             void tst_Domain::cleanupTestCase()
             {
             }
             void tst_Domain::init()
             {
             }
             void tst_Domain::cleanup()
             {
             }
             void tst_Domain::domain()
             {
                 Domain domain;
                 QCOMPARE(domain.isEmpty(), true);
                 QCOMPARE(domain.maxX(), 0.0);
                 QCOMPARE(domain.maxY(), 0.0);
                 QCOMPARE(domain.minX(), 0.0);
                 QCOMPARE(domain.minY(), 0.0);
             }
             void tst_Domain::handleAxisUpdatedX_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("-1 1") << -1.0 << 1.0;
                 QTest::newRow("0 1") << 0.0 << 1.0;
                 QTest::newRow("-1 0") << -1.0 << 0.0;
             }
             void tst_Domain::handleAxisUpdatedX()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
                 AxisMock axis(Qt::Horizontal);
                 QObject::connect(&axis,SIGNAL(updated()),&domain,SLOT(handleAxisUpdated()));
                 axis.m_min=min;
                 axis.m_max=max;
                 axis.emitUpdated();
-                QVERIFY(qFuzzyIsNull(domain.minX() - min));
+                QVERIFY(qFuzzyCompare(domain.minX(), min));
-                QVERIFY(qFuzzyIsNull(domain.maxX() - max));
+                QVERIFY(qFuzzyCompare(domain.maxX(), max));
                 QList<QVariant> arg1 = spy1.first();
-                QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
+                QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min));
-                QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
+                QVERIFY(qFuzzyCompare(arg1.at(1).toReal(), max));
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 0);
             }
             void tst_Domain::handleAxisUpdatedY_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("-1 1") << -1.0 << 1.0;
                 QTest::newRow("0 1") << 0.0 << 1.0;
                 QTest::newRow("-1 0") << -1.0 << 0.0;
             }
             void tst_Domain::handleAxisUpdatedY()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
                 AxisMock axis(Qt::Vertical);
                 QObject::connect(&axis, SIGNAL(updated()), &domain, SLOT(handleAxisUpdated()));
                 axis.m_min = min;
                 axis.m_max = max;
                 axis.emitUpdated();
-                QVERIFY(qFuzzyIsNull(domain.minY() - min));
+                QVERIFY(qFuzzyCompare(domain.minY(), min));
-                QVERIFY(qFuzzyIsNull(domain.maxY() - max));
+                QVERIFY(qFuzzyCompare(domain.maxY(), max));
                 QList<QVariant> arg1 = spy2.first();
-                QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
+                QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min));
-                QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
+                QVERIFY(qFuzzyCompare(arg1.at(1).toReal(), max));
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 1);
             }
             void tst_Domain::isEmpty_data()
             {
                 QTest::addColumn<qreal>("minX");
                 QTest::addColumn<qreal>("maxX");
                 QTest::addColumn<qreal>("minY");
                 QTest::addColumn<qreal>("maxY");
                 QTest::addColumn<bool>("isEmpty");
                 QTest::newRow("0 0 0 0") << 0.0 << 0.0 << 0.0 << 0.0 << true;
                 QTest::newRow("0 1 0 0") << 0.0 << 1.0 << 0.0 << 0.0 << true;
                 QTest::newRow("0 0 0 1") << 0.0 << 1.0 << 0.0 << 0.0 << true;
                 QTest::newRow("0 1 0 1") << 0.0 << 1.0 << 0.0 << 1.0 << false;
             }
             void tst_Domain::isEmpty()
             {
                 QFETCH(qreal, minX);
                 QFETCH(qreal, maxX);
                 QFETCH(qreal, minY);
                 QFETCH(qreal, maxY);
                 QFETCH(bool, isEmpty);
                 Domain domain;
                 domain.setRange(minX, maxX, minY, maxY);
                 QCOMPARE(domain.isEmpty(), isEmpty);
             }
             void tst_Domain::maxX_data()
             {
                 QTest::addColumn<qreal>("maxX1");
                 QTest::addColumn<qreal>("maxX2");
                 QTest::addColumn<int>("count");
                 QTest::newRow("1") << 0.0 << 1.0 << 1;
                 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
                 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
             }
             void tst_Domain::maxX()
             {
                 QFETCH(qreal, maxX1);
                 QFETCH(qreal, maxX2);
                 QFETCH(int, count);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
                 domain.setMaxX(maxX1);
                 QCOMPARE(domain.maxX(), maxX1);
                 domain.setMaxX(maxX2);
                 QCOMPARE(domain.maxX(), maxX2);
                 TRY_COMPARE(spy0.count(), count);
                 TRY_COMPARE(spy1.count(), count);
                 TRY_COMPARE(spy2.count(), 0);
             }
             void tst_Domain::maxY_data()
             {
                 QTest::addColumn<qreal>("maxY1");
                 QTest::addColumn<qreal>("maxY2");
                 QTest::addColumn<int>("count");
                 QTest::newRow("1") << 0.0 << 1.0 << 1;
                 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
                 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
             }
             void tst_Domain::maxY()
             {
                 QFETCH(qreal, maxY1);
                 QFETCH(qreal, maxY2);
                 QFETCH(int, count);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
                 domain.setMaxY(maxY1);
                 QCOMPARE(domain.maxY(), maxY1);
                 domain.setMaxY(maxY2);
                 QCOMPARE(domain.maxY(), maxY2);
                 TRY_COMPARE(spy0.count(), count);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), count);
             }
             void tst_Domain::minX_data()
             {
                 QTest::addColumn<qreal>("minX1");
                 QTest::addColumn<qreal>("minX2");
                 QTest::addColumn<int>("count");
                 QTest::newRow("1") << 0.0 << 1.0 << 1;
                 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
                 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
             }
             void tst_Domain::minX()
             {
                 QFETCH(qreal, minX1);
                 QFETCH(qreal, minX2);
                 QFETCH(int, count);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
                 domain.setMinX(minX1);
                 QCOMPARE(domain.minX(), minX1);
                 domain.setMinX(minX2);
                 QCOMPARE(domain.minX(), minX2);
                 TRY_COMPARE(spy0.count(), count);
                 TRY_COMPARE(spy1.count(), count);
                 TRY_COMPARE(spy2.count(), 0);
             }
             void tst_Domain::minY_data()
             {
                 QTest::addColumn<qreal>("minY1");
                 QTest::addColumn<qreal>("minY2");
                 QTest::addColumn<int>("count");
                 QTest::newRow("1") << 0.0 << 1.0 << 1;
                 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
                 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
             }
             void tst_Domain::minY()
             {
                 QFETCH(qreal, minY1);
                 QFETCH(qreal, minY2);
                 QFETCH(int, count);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
                 domain.setMinY(minY1);
                 QCOMPARE(domain.minY(), minY1);
                 domain.setMinY(minY2);
                 QCOMPARE(domain.minY(), minY2);
                 TRY_COMPARE(spy0.count(), count);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), count);
             }
             void tst_Domain::operatorEquals_data()
             {
                 QTest::addColumn<Domain*>("domain1");
                 QTest::addColumn<Domain*>("domain2");
                 QTest::addColumn<bool>("equals");
                 QTest::addColumn<bool>("notEquals");
                 Domain* a;
                 Domain* b;
                 a = new Domain();
                 a->setRange(0, 100, 0, 100);
                 b = new Domain();
                 b->setRange(0, 100, 0, 100);
                 QTest::newRow("equals") << a << b << true << false;
                 a = new Domain();
                 a->setRange(0, 100, 0, 100);
                 b = new Domain();
                 b->setRange(0, 100, 0, 1);
                 QTest::newRow("equals") << a << b << false << true;
                 a = new Domain();
                 a->setRange(0, 100, 0, 100);
                 b = new Domain();
                 b->setRange(0, 1, 0, 100);
                 QTest::newRow("equals") << a << b << false << true;
             }
             void tst_Domain::operatorEquals()
             {
                 QFETCH(Domain*, domain1);
                 QFETCH(Domain*, domain2);
                 QFETCH(bool, equals);
                 QFETCH(bool, notEquals);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
                 QCOMPARE(*domain1==*domain2, equals);
                 QCOMPARE(*domain1!=*domain2, notEquals);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
             }
             void tst_Domain::setRange_data()
             {
                 QTest::addColumn<qreal>("minX");
                 QTest::addColumn<qreal>("maxX");
                 QTest::addColumn<qreal>("minY");
                 QTest::addColumn<qreal>("maxY");
                 QTest::newRow("1,2,1,2") << 1.0 << 2.0 << 1.0 << 2.0;
                 QTest::newRow("1,3,1,3") << 1.0 << 3.0 << 1.0 << 3.0;
                 QTest::newRow("-1,5,-2,-1") << -1.0 << 5.0 << -2.0 << -1.0;
             }
             void tst_Domain::setRange()
             {
                 QFETCH(qreal, minX);
                 QFETCH(qreal, maxX);
                 QFETCH(qreal, minY);
                 QFETCH(qreal, maxY);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
                 domain.setRange(minX, maxX, minY, maxY);
                 QCOMPARE(domain.minX(), minX);
                 QCOMPARE(domain.maxX(), maxX);
                 QCOMPARE(domain.minY(), minY);
                 QCOMPARE(domain.maxY(), maxY);
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 1);
             }
             void tst_Domain::setRangeX_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("-1 1") << -1.0 << 1.0;
                 QTest::newRow("0 1") << 0.0 << 1.0;
                 QTest::newRow("-1 0") << -1.0 << 0.0;
             }
             void tst_Domain::setRangeX()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
                 domain.setRangeX(min, max);
-                QVERIFY(qFuzzyIsNull(domain.minX() - min));
+                QVERIFY(qFuzzyCompare(domain.minX(), min));
-                QVERIFY(qFuzzyIsNull(domain.maxX() - max));
+                QVERIFY(qFuzzyCompare(domain.maxX(), max));
                 QList<QVariant> arg1 = spy1.first();
-                QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
+                QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min));
-                QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
+                QVERIFY(qFuzzyCompare(arg1.at(1).toReal(), max));
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 0);
             }
             void tst_Domain::setRangeY_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("-1 1") << -1.0 << 1.0;
                 QTest::newRow("0 1") << 0.0 << 1.0;
                 QTest::newRow("-1 0") << -1.0 << 0.0;
             }
             void tst_Domain::setRangeY()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
                 domain.setRangeY(min, max);
-                QVERIFY(qFuzzyIsNull(domain.minY() - min));
+                QVERIFY(qFuzzyCompare(domain.minY(), min));
-                QVERIFY(qFuzzyIsNull(domain.maxY() - max));
+                QVERIFY(qFuzzyCompare(domain.maxY(), max));
                 QList<QVariant> arg1 = spy2.first();
-                QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
+                QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min));
-                QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
+                QVERIFY(qFuzzyCompare(arg1.at(1).toReal(), max));
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 1);
             }
             void tst_Domain::spanX_data()
             {
                 QTest::addColumn<qreal>("minX");
                 QTest::addColumn<qreal>("maxX");
                 QTest::addColumn<qreal>("spanX");
                 QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0;
                 QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0;
             }
             void tst_Domain::spanX()
             {
                 QFETCH(qreal, minX);
                 QFETCH(qreal, maxX);
                 QFETCH(qreal, spanX);
                 Domain domain;
                 domain.setRangeX(minX, maxX);
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
                 QCOMPARE(domain.spanX(), spanX);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
             }
             void tst_Domain::spanY_data()
             {
                 QTest::addColumn<qreal>("minY");
                 QTest::addColumn<qreal>("maxY");
                 QTest::addColumn<qreal>("spanY");
                 QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0;
                 QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0;
             }
             void tst_Domain::spanY()
             {
                 QFETCH(qreal, minY);
                 QFETCH(qreal, maxY);
                 QFETCH(qreal, spanY);
                 Domain domain;
                 domain.setRangeY(minY, maxY);
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
                 QCOMPARE(domain.spanY(), spanY);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
             }
             void tst_Domain::zoom_data()
             {
                 QTest::addColumn<QRectF>("rect0");
                 QTest::addColumn<QSizeF>("size0");
                 QTest::addColumn<QRectF>("rect1");
                 QTest::addColumn<QSizeF>("size1");
                 QTest::addColumn<QRectF>("rect2");
                 QTest::addColumn<QSizeF>("size2");
                 QTest::newRow("first") << QRectF(10, 10, 100, 100) << QSizeF(1000, 1000)
                     << QRectF(20, 20, 100, 100) << QSizeF(1000, 1000) << QRectF(50, 50, 100, 100)
                     << QSizeF(1000, 1000);
                 QTest::newRow("scound") << QRectF(10, 10, 50, 50) << QSizeF(1000, 1000)
                     << QRectF(20, 20, 100, 100) << QSizeF(1000, 1000) << QRectF(50, 50, 100, 100)
                     << QSizeF(1000, 1000);
                 QTest::newRow("third") << QRectF(10, 10, 10, 10) << QSizeF(100, 100) << QRectF(20, 20, 20, 20)
                     << QSizeF(100, 100) << QRectF(50, 50, 50, 50) << QSizeF(100, 100);
             }
             void tst_Domain::zoom()
             {
                 QFETCH(QRectF, rect0);
                 QFETCH(QSizeF, size0);
                 QFETCH(QRectF, rect1);
                 QFETCH(QSizeF, size1);
                 QFETCH(QRectF, rect2);
                 QFETCH(QSizeF, size2);
                 Domain domain;
                 domain.setRange(0, 1000, 0, 1000);
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
                 Domain domain0;
                 domain0.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
                 domain.zoomIn(rect0, size0);
                 Domain domain1;
                 domain1.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
                 domain.zoomIn(rect1, size1);
                 Domain domain2;
                 domain2.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
                 domain.zoomIn(rect2, size2);
                 domain.zoomOut(rect2, size2);
                 QCOMPARE(domain == domain2, true);
                 domain.zoomOut(rect1, size1);
                 QCOMPARE(domain == domain1, true);
                 domain.zoomOut(rect0, size0);
                 QCOMPARE(domain == domain0, true);
                 TRY_COMPARE(spy0.count(), 6);
                 TRY_COMPARE(spy1.count(), 6);
                 TRY_COMPARE(spy2.count(), 6);
             }
             void tst_Domain::move_data()
             {
                 QTest::addColumn<int>("dx");
                 QTest::addColumn<int>("dy");
                 QTest::addColumn<QSizeF>("size");
                 QTest::newRow("dx 100, dy 0, size 1000x1000") << 100 << 0 << QSizeF(1000, 1000);
                 QTest::newRow("dx 0,  dy 100, size 1000x1000") << 0 << 100 << QSizeF(1000, 1000);
                 QTest::newRow("dx -100, dy 0, size 1000x1000") << -100 << 0 << QSizeF(1000, 1000);
                 QTest::newRow("dx 0, dy -100, size 1000x1000") << 0 << -100 << QSizeF(1000, 1000);
                 QTest::newRow("dx 100, dy 100, size 1000x1000") << 100 << 100 << QSizeF(1000, 1000);
                 QTest::newRow("dx 100, dy 50, size 1000x1000") << 100 << 50 << QSizeF(1000, 1000);
             }
             void tst_Domain::move()
             {
                 QFETCH(int, dx);
                 QFETCH(int, dy);
                 QFETCH(QSizeF, size);
                 Domain domain;
                 domain.setRange(0, size.width(), 0, size.height());
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
                 domain.move(dx, dy, size);
                 Domain result;
                 result.setRange(dx, size.width() + dx, dy, size.height() + dy);
                 QCOMPARE(domain == result, true);
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), (dx != 0 ? 1 : 0));
                 TRY_COMPARE(spy2.count(), (dy != 0 ? 1 : 0));
             }
             QTEST_MAIN(tst_Domain)
             #include "tst_domain.moc"
             #endif

tests/auto/qbarset/tst_qbarset.cpp +11 -11

             /****************************************************************************
             **
             ** 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 <QtTest/QtTest>
             #include <qbarset.h>
             #include <qbarseries.h>
             #include <qchartview.h>
             #include "tst_definitions.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             class tst_QBarSet : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qbarset_data();
                 void qbarset();
                 void label_data();
                 void label();
                 void append_data();
                 void append();
                 void appendOperator_data();
                 void appendOperator();
                 void insert_data();
                 void insert();
                 void remove_data();
                 void remove();
                 void replace_data();
                 void replace();
                 void at_data();
                 void at();
                 void atOperator_data();
                 void atOperator();
                 void count_data();
                 void count();
                 void sum_data();
                 void sum();
                 void customize();
             private:
                 QBarSet* m_barset;
             };
             void tst_QBarSet::initTestCase()
             {
             }
             void tst_QBarSet::cleanupTestCase()
             {
             }
             void tst_QBarSet::init()
             {
                  m_barset = new QBarSet(QString("label"));
             }
             void tst_QBarSet::cleanup()
             {
                 delete m_barset;
                 m_barset = 0;
             }
             void tst_QBarSet::qbarset_data()
             {
             }
             void tst_QBarSet::qbarset()
             {
                 QBarSet barset(QString("label"));
                 QCOMPARE(barset.label(), QString("label"));
                 QCOMPARE(barset.count(), 0);
-                QVERIFY(qFuzzyIsNull(barset.sum()));
+                QVERIFY(qFuzzyCompare(barset.sum(), 0));
             }
             void tst_QBarSet::label_data()
             {
                 QTest::addColumn<QString> ("label");
                 QTest::addColumn<QString> ("result");
                 QTest::newRow("label0") << QString("label0") << QString("label0");
                 QTest::newRow("label1") << QString("label1") << QString("label1");
             }
             void tst_QBarSet::label()
             {
                 QFETCH(QString, label);
                 QFETCH(QString, result);
                 QSignalSpy labelSpy(m_barset,SIGNAL(labelChanged()));
                 m_barset->setLabel(label);
                 QCOMPARE(m_barset->label(), result);
                 QVERIFY(labelSpy.count() == 1);
             }
             void tst_QBarSet::append_data()
             {
                 QTest::addColumn<int> ("count");
                 QTest::newRow("0") << 0;
                 QTest::newRow("5") << 5;
                 QTest::newRow("100") << 100;
                 QTest::newRow("1000") << 1000;
             }
             void tst_QBarSet::append()
             {
                 QFETCH(int, count);
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 QSignalSpy valueSpy(m_barset, SIGNAL(valuesAdded(int,int)));
                 qreal sum(0.0);
                 qreal value(0.0);
                 for (int i=0; i<count; i++) {
                     m_barset->append(value);
                     QCOMPARE(m_barset->at(i), value);
                     sum += value;
                     value += 1.0;
                 }
                 QCOMPARE(m_barset->count(), count);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), sum));
                 QCOMPARE(valueSpy.count(), count);
             }
             void tst_QBarSet::appendOperator_data()
             {
                 append_data();
             }
             void tst_QBarSet::appendOperator()
             {
                 QFETCH(int, count);
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesAdded(int,int)));
                 qreal sum(0.0);
                 qreal value(0.0);
                 for (int i=0; i<count; i++) {
                     *m_barset << value;
                     QCOMPARE(m_barset->at(i), value);
                     sum += value;
                     value += 1.0;
                 }
                 QCOMPARE(m_barset->count(), count);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), sum));
                 QCOMPARE(valueSpy.count(), count);
             }
             void tst_QBarSet::insert_data()
             {
             }
             void tst_QBarSet::insert()
             {
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesAdded(int,int)));
                 m_barset->insert(0, 1.0);       // 1.0
                 QCOMPARE(m_barset->at(0), 1.0);
                 QCOMPARE(m_barset->count(), 1);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), (qreal)1.0));
                 m_barset->insert(0, 2.0);       // 2.0 1.0
                 QCOMPARE(m_barset->at(0), 2.0);
                 QCOMPARE(m_barset->at(1), 1.0);
                 QCOMPARE(m_barset->count(), 2);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), (qreal)3.0));
                 m_barset->insert(1, 3.0);       // 2.0 3.0 1.0
                 QCOMPARE(m_barset->at(1), 3.0);
                 QCOMPARE(m_barset->at(0), 2.0);
                 QCOMPARE(m_barset->at(2), 1.0);
                 QCOMPARE(m_barset->count(), 3);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), (qreal)6.0));
                 QCOMPARE(valueSpy.count(), 3);
             }
             void tst_QBarSet::remove_data()
             {
             }
             void tst_QBarSet::remove()
             {
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesRemoved(int,int)));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->count(), 4);
                 QCOMPARE(m_barset->sum(), 10.0);
                 // Remove middle
                 m_barset->remove(2);                // 1.0 2.0 4.0
                 QCOMPARE(m_barset->at(0), 1.0);
                 QCOMPARE(m_barset->at(1), 2.0);
                 QCOMPARE(m_barset->at(2), 4.0);
                 QCOMPARE(m_barset->count(), 3);
                 QCOMPARE(m_barset->sum(), 7.0);
                 QCOMPARE(valueSpy.count(), 1);
                 QList<QVariant> valueSpyArg = valueSpy.takeFirst();
                 // Verify index of removed signal
                 QVERIFY(valueSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(valueSpyArg.at(0).toInt() == 2);
                 // Verify count of removed signal
                 QVERIFY(valueSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(valueSpyArg.at(1).toInt() == 1);
                 // Remove first
                 m_barset->remove(0);                // 2.0 4.0
                 QCOMPARE(m_barset->at(0), 2.0);
                 QCOMPARE(m_barset->at(1), 4.0);
                 QCOMPARE(m_barset->count(), 2);
                 QCOMPARE(m_barset->sum(), 6.0);
                 QCOMPARE(valueSpy.count(), 1);
                 valueSpyArg = valueSpy.takeFirst();
                 // Verify index of removed signal
                 QVERIFY(valueSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(valueSpyArg.at(0).toInt() == 0);
                 // Verify count of removed signal
                 QVERIFY(valueSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(valueSpyArg.at(1).toInt() == 1);
                 // Illegal indexes
                 m_barset->remove(4);
                 QCOMPARE(m_barset->count(), 2);
                 QCOMPARE(m_barset->sum(), 6.0);
                 m_barset->remove(-1);
                 QCOMPARE(m_barset->count(), 2);
                 QCOMPARE(m_barset->sum(), 6.0);
                 // nothing removed, no signals should be emitted
                 QCOMPARE(valueSpy.count(), 0);
                 // Remove more items than list has
                 m_barset->remove(0,312);
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 QCOMPARE(valueSpy.count(), 1);
                 valueSpyArg = valueSpy.takeFirst();
                 // Verify index of removed signal
                 QVERIFY(valueSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(valueSpyArg.at(0).toInt() == 0);
                 // Verify count of removed signal (expect 2 values removed, because list had only 2 items)
                 QVERIFY(valueSpyArg.at(1).type() == QVariant::Int);
                 QVERIFY(valueSpyArg.at(1).toInt() == 2);
             }
             void tst_QBarSet::replace_data()
             {
             }
             void tst_QBarSet::replace()
             {
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valueChanged(int)));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->count(), 4);
                 QCOMPARE(m_barset->sum(), 10.0);
                 // Replace first
                 m_barset->replace(0, 5.0);          // 5.0 2.0 3.0 4.0
                 QCOMPARE(m_barset->count(), 4);
                 QCOMPARE(m_barset->sum(), 14.0);
                 QCOMPARE(m_barset->at(0), 5.0);
                 // Replace last
                 m_barset->replace(3, 6.0);
                 QCOMPARE(m_barset->count(), 4);     // 5.0 2.0 3.0 6.0
                 QCOMPARE(m_barset->sum(), 16.0);
                 QCOMPARE(m_barset->at(0), 5.0);
                 QCOMPARE(m_barset->at(1), 2.0);
                 QCOMPARE(m_barset->at(2), 3.0);
                 QCOMPARE(m_barset->at(3), 6.0);
                 // Illegal indexes
                 m_barset->replace(4, 6.0);
                 QCOMPARE(m_barset->count(), 4);     // 5.0 2.0 3.0 6.0
                 QCOMPARE(m_barset->sum(), 16.0);
                 m_barset->replace(-1, 6.0);
                 QCOMPARE(m_barset->count(), 4);     // 5.0 2.0 3.0 6.0
                 QCOMPARE(m_barset->sum(), 16.0);
                 m_barset->replace(4, 1.0);
                 QCOMPARE(m_barset->count(), 4);     // 5.0 2.0 3.0 6.0
                 QCOMPARE(m_barset->sum(), 16.0);
                 m_barset->replace(-1, 1.0);
                 QCOMPARE(m_barset->count(), 4);     // 5.0 2.0 3.0 6.0
                 QCOMPARE(m_barset->sum(), 16.0);
                 QVERIFY(valueSpy.count() == 2);
             }
             void tst_QBarSet::at_data()
             {
             }
             void tst_QBarSet::at()
             {
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->at(0), 1.0);
                 QCOMPARE(m_barset->at(1), 2.0);
                 QCOMPARE(m_barset->at(2), 3.0);
                 QCOMPARE(m_barset->at(3), 4.0);
             }
             void tst_QBarSet::atOperator_data()
             {
             }
             void tst_QBarSet::atOperator()
             {
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
                 m_barset->append(3.0);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->operator [](0), 1.0);
                 QCOMPARE(m_barset->operator [](1), 2.0);
                 QCOMPARE(m_barset->operator [](2), 3.0);
                 QCOMPARE(m_barset->operator [](3), 4.0);
             }
             void tst_QBarSet::count_data()
             {
             }
             void tst_QBarSet::count()
             {
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 m_barset->append(1.0);
                 QCOMPARE(m_barset->count(),1);
                 m_barset->append(2.0);
                 QCOMPARE(m_barset->count(),2);
                 m_barset->append(3.0);
                 QCOMPARE(m_barset->count(),3);
                 m_barset->append(4.0);
                 QCOMPARE(m_barset->count(),4);
             }
             void tst_QBarSet::sum_data()
             {
             }
             void tst_QBarSet::sum()
             {
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 m_barset->append(1.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), (qreal)1.0));
                 m_barset->append(2.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), (qreal)3.0));
                 m_barset->append(3.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), (qreal)6.0));
                 m_barset->append(4.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), (qreal)10.0));
             }
             void tst_QBarSet::customize()
             {
                 // Create sets
                 QBarSet *set1 = new QBarSet("set1");
                 QBarSet *set2 = new QBarSet("set2");
                 // Append set1 to series
                 QBarSeries *series = new QBarSeries();
                 bool success = series->append(set1);
                 QVERIFY(success);
                 // Add series to the chart
                 QChartView view(new QChart());
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Test adding data to the sets
                 *set1 << 1 << 2 << 1 << 3;
                 *set2 << 2 << 1 << 3 << 1;
                 // Remove sets from series
                 series->take(set1);
                 series->take(set2);
                 // Test pen
                 QVERIFY(set1->pen() != QPen());
                 QVERIFY(set2->pen() == QPen());
                 QPen pen(QColor(128,128,128,128));
                 set1->setPen(pen);
                 // Add sets back to series
                 series->append(set1);
                 series->append(set2);
                 QVERIFY(set1->pen() == pen);      // Should be customized
                 QVERIFY(set2->pen() != QPen());   // Should be decorated by theme
                 // Remove sets from series
                 series->take(set1);
                 series->take(set2);
                 // Test brush
                 set2->setBrush(QBrush());
                 QVERIFY(set1->brush() != QBrush());
                 QVERIFY(set2->brush() == QBrush());
                 QBrush brush(QColor(128,128,128,128));
                 set1->setBrush(brush);
                 // Add sets back to series
                 series->append(set1);
                 series->append(set2);
                 QVERIFY(set1->brush() == brush);    // Should be customized
                 QVERIFY(set2->brush() != QBrush()); // Should be decorated by theme
                 // Remove sets from series
                 series->take(set1);
                 series->take(set2);
                 // Test label brush
                 set2->setLabelBrush(QBrush());
                 QVERIFY(set1->labelBrush() != QBrush());
                 QVERIFY(set2->labelBrush() == QBrush());
                 set1->setLabelBrush(brush);
                 series->append(set1);
                 series->append(set2);
                 QVERIFY(set1->labelBrush() == brush);       // Should be customized
                 QVERIFY(set2->labelBrush() != QBrush());    // Should be decorated by theme
                 // Test label font
                 // Note: QFont empty constructor creates font with application's default font, so the font may or may not be the
                 // same for the set added to the series  (depending on the QChart's theme configuration)
                 QVERIFY(set1->labelFont() != QFont() || set1->labelFont() == QFont());
                 QVERIFY(set2->labelFont() == QFont());
                 QFont font;
                 font.setBold(true);
                 font.setItalic(true);
                 set1->setLabelFont(font);
                 QVERIFY(set1->labelFont() == font);
                 QVERIFY(set2->labelFont() == QFont());
                 // Test adding data to the sets
                 *set1 << 1 << 2 << 1 << 3;
                 *set2 << 2 << 1 << 3 << 1;
             }
             QTEST_MAIN(tst_QBarSet)
             #include "tst_qbarset.moc"

tests/auto/qcategoryaxis/tst_qcategoryaxis.cpp +8 -8

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "../qabstractaxis/tst_qabstractaxis.h"
             #include "qcategoryaxis.h"
             #include <qlineseries.h>
             class tst_QCategoryAxis: public tst_QAbstractAxis
             {
             Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qcategoryaxis_data();
                 void qcategoryaxis();
                 void max_raw_data();
                 void max_raw();
                 void max_data();
                 void max();
                 void max_animation_data();
                 void max_animation();
                 void min_raw_data();
                 void min_raw();
                 void min_data();
                 void min();
                 void min_animation_data();
                 void min_animation();
                 void range_raw_data();
                 void range_raw();
                 void range_data();
                 void range();
                 void range_animation_data();
                 void range_animation();
                 void interval_data();
                 void interval();
             private:
                 QCategoryAxis* m_categoryaxis;
                 QLineSeries* m_series;
             };
             void tst_QCategoryAxis::initTestCase()
             {
             }
             void tst_QCategoryAxis::cleanupTestCase()
             {
             }
             void tst_QCategoryAxis::init()
             {
                 m_categoryaxis = new QCategoryAxis();
                 m_series = new QLineSeries();
                 *m_series << QPointF(-100, -100) << QPointF(0, 0) << QPointF(100, 100);
                 tst_QAbstractAxis::init(m_categoryaxis, m_series);
                 m_chart->addSeries(m_series);
                 m_chart->createDefaultAxes();
             }
             void tst_QCategoryAxis::cleanup()
             {
                 delete m_series;
                 delete m_categoryaxis;
                 m_series = 0;
                 m_categoryaxis = 0;
                 tst_QAbstractAxis::cleanup();
             }
             void tst_QCategoryAxis::qcategoryaxis_data()
             {
             }
             void tst_QCategoryAxis::qcategoryaxis()
             {
                 qabstractaxis();
-                QVERIFY(qFuzzyIsNull(m_categoryaxis->max()));
+                QVERIFY(qFuzzyCompare(m_categoryaxis->max(), 0));
-                QVERIFY(qFuzzyIsNull(m_categoryaxis->min()));
+                QVERIFY(qFuzzyCompare(m_categoryaxis->min(), 0));
                 QCOMPARE(m_categoryaxis->type(), QAbstractAxis::AxisTypeCategory);
                 m_chart->setAxisX(m_categoryaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
-                QVERIFY(!qFuzzyIsNull(m_categoryaxis->max()));
+                QVERIFY(!qFuzzyCompare(m_categoryaxis->max(), 0));
-                QVERIFY(!qFuzzyIsNull(m_categoryaxis->min()));
+                QVERIFY(!qFuzzyCompare(m_categoryaxis->min(), 0));
             }
             void tst_QCategoryAxis::max_raw_data()
             {
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0") << (qreal)1.0;
                 QTest::newRow("50.0") << (qreal)50.0;
                 QTest::newRow("101.0") << (qreal)101.0;
             }
             void tst_QCategoryAxis::max_raw()
             {
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_categoryaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_categoryaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_categoryaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_categoryaxis->setMax(max);
-                QVERIFY2(qFuzzyIsNull(m_categoryaxis->max() - max), "Not equal");
+                QVERIFY2(qFuzzyCompare(m_categoryaxis->max(), max), "Not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QCategoryAxis::max_data()
             {
                 max_raw_data();
             }
             void tst_QCategoryAxis::max()
             {
                 m_chart->setAxisX(m_categoryaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 max_raw();
             }
             void tst_QCategoryAxis::max_animation_data()
             {
                 max_data();
             }
             void tst_QCategoryAxis::max_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 max();
             }
             void tst_QCategoryAxis::min_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::newRow("-1.0") << (qreal)-1.0;
                 QTest::newRow("-50.0") << (qreal)-50.0;
                 QTest::newRow("-101.0") << (qreal)-101.0;
             }
             void tst_QCategoryAxis::min_raw()
             {
                 QFETCH(qreal, min);
                 QSignalSpy spy0(m_categoryaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_categoryaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_categoryaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_categoryaxis->setMin(min);
-                QVERIFY2(qFuzzyIsNull(m_categoryaxis->min() - min), "Not equal");
+                QVERIFY2(qFuzzyCompare(m_categoryaxis->min(), min), "Not equal");
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QCategoryAxis::min_data()
             {
                 min_raw_data();
             }
             void tst_QCategoryAxis::min()
             {
                 m_chart->setAxisX(m_categoryaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 min_raw();
             }
             void tst_QCategoryAxis::min_animation_data()
             {
                 min_data();
             }
             void tst_QCategoryAxis::min_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 min();
             }
             void tst_QCategoryAxis::range_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0 - 101.0") << (qreal)-1.0 << (qreal)101.0;
                 QTest::newRow("25.0 - 75.0") << (qreal)25.0 << (qreal)75.0;
                 QTest::newRow("101.0") << (qreal)40.0 << (qreal)60.0;
                 QTest::newRow("-35.0 - 0.0") << (qreal)-35.0 << (qreal)10.0;
                 QTest::newRow("-35.0 - 0.0") << (qreal)-35.0 << (qreal)-15.0;
                 QTest::newRow("0.0 - 0.0") << (qreal)-0.1 << (qreal)0.1;
             }
             void tst_QCategoryAxis::range_raw()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_categoryaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_categoryaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_categoryaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_categoryaxis->setRange(min, max);
-                QVERIFY2(qFuzzyIsNull(m_categoryaxis->min() - min), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_categoryaxis->min(), min), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_categoryaxis->max() - max), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_categoryaxis->max(), max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QCategoryAxis::range_data()
             {
                 range_raw_data();
             }
             void tst_QCategoryAxis::range()
             {
                 m_chart->setAxisX(m_categoryaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 range_raw();
             }
             void tst_QCategoryAxis::range_animation_data()
             {
                 range_data();
             }
             void tst_QCategoryAxis::range_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 range();
             }
             void tst_QCategoryAxis::interval_data()
             {
                 //
             }
             void tst_QCategoryAxis::interval()
             {
                 // append one correct interval
                 m_categoryaxis->append("first", (qreal)45);
                 QCOMPARE(m_categoryaxis->startValue("first"), (qreal)0);
                 QCOMPARE(m_categoryaxis->endValue("first"), (qreal)45);
                 // append one more correct interval
                 m_categoryaxis->append("second", (qreal)75);
                 QCOMPARE(m_categoryaxis->startValue("second"), (qreal)45);
                 QCOMPARE(m_categoryaxis->endValue("second"), (qreal)75);
                 // append one incorrect interval
                 m_categoryaxis->append("third", (qreal)15);
                 QCOMPARE(m_categoryaxis->count(), 2);
                 QCOMPARE(m_categoryaxis->endValue(m_categoryaxis->categoriesLabels().last()), (qreal)75);
             //    QCOMPARE(intervalMax("first"), (qreal)75);
                 // append one more correct interval
                 m_categoryaxis->append("third", (qreal)100);
                 QCOMPARE(m_categoryaxis->count(), 3);
                 QCOMPARE(m_categoryaxis->startValue("third"), (qreal)75);
                 QCOMPARE(m_categoryaxis->endValue("third"), (qreal)100);
                 // remove one interval
                 m_categoryaxis->remove("first");
                 QCOMPARE(m_categoryaxis->count(), 2);
                 QCOMPARE(m_categoryaxis->startValue("second"), (qreal)0); // second interval should extend to firstInterval minimum
                 QCOMPARE(m_categoryaxis->endValue("second"), (qreal)75);
                 // remove one interval
                 m_categoryaxis->replaceLabel("second", "replaced");
                 QCOMPARE(m_categoryaxis->count(), 2);
                 QCOMPARE(m_categoryaxis->startValue("replaced"), (qreal)0); // second interval should extend to firstInterval minimum
                 QCOMPARE(m_categoryaxis->endValue("replaced"), (qreal)75);
             }
             QTEST_MAIN(tst_QCategoryAxis)
             #include "tst_qcategoryaxis.moc"

tests/auto/qvalueaxis/tst_qvalueaxis.cpp +23 -23

             /****************************************************************************
              **
              ** 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 "../qabstractaxis/tst_qabstractaxis.h"
             #include "qvalueaxis.h"
             #include <qlineseries.h>
             class tst_QValueAxis: public tst_QAbstractAxis
             {
             Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qvalueaxis_data();
                 void qvalueaxis();
                 void max_raw_data();
                 void max_raw();
                 void max_data();
                 void max();
                 void max_animation_data();
                 void max_animation();
                 void min_raw_data();
                 void min_raw();
                 void min_data();
                 void min();
                 void min_animation_data();
                 void min_animation();
                 void niceNumbersEnabled_data();
                 void niceNumbersEnabled();
                 void range_raw_data();
                 void range_raw();
                 void range_data();
                 void range();
                 void range_animation_data();
                 void range_animation();
                 void ticksCount_data();
                 void ticksCount();
                 void noautoscale_data();
                 void noautoscale();
                 void autoscale_data();
                 void autoscale();
             private:
                 QValueAxis* m_valuesaxis;
                 QLineSeries* m_series;
             };
             void tst_QValueAxis::initTestCase()
             {
             }
             void tst_QValueAxis::cleanupTestCase()
             {
             }
             void tst_QValueAxis::init()
             {
                 m_valuesaxis = new QValueAxis();
                 m_series = new QLineSeries();
                 *m_series << QPointF(-100, -100) << QPointF(0, 0) << QPointF(100, 100);
                 tst_QAbstractAxis::init(m_valuesaxis,m_series);
                 m_chart->addSeries(m_series);
                 m_chart->createDefaultAxes();
             }
             void tst_QValueAxis::cleanup()
             {
                 delete m_series;
                 delete m_valuesaxis;
                 m_series = 0;
                 m_valuesaxis = 0;
                 tst_QAbstractAxis::cleanup();
             }
             void tst_QValueAxis::qvalueaxis_data()
             {
             }
             void tst_QValueAxis::qvalueaxis()
             {
                 qabstractaxis();
-                QVERIFY(qFuzzyIsNull(m_valuesaxis->max()));
+                QVERIFY(qFuzzyCompare(m_valuesaxis->max(), 0));
-                QVERIFY(qFuzzyIsNull(m_valuesaxis->min()));
+                QVERIFY(qFuzzyCompare(m_valuesaxis->min(), 0));
                 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), false);
                 QCOMPARE(m_valuesaxis->tickCount(), 5);
                 QCOMPARE(m_valuesaxis->type(), QAbstractAxis::AxisTypeValue);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
-                QVERIFY(!qFuzzyIsNull(m_valuesaxis->max()));
+                QVERIFY(!qFuzzyCompare(m_valuesaxis->max(), 0));
-                QVERIFY(!qFuzzyIsNull(m_valuesaxis->min()));
+                QVERIFY(!qFuzzyCompare(m_valuesaxis->min(), 0));
                 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), false);
                 QCOMPARE(m_valuesaxis->tickCount(), 5);
             }
             void tst_QValueAxis::max_raw_data()
             {
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0") << (qreal)1.0;
                 QTest::newRow("50.0") << (qreal)50.0;
                 QTest::newRow("101.0") << (qreal)101.0;
             }
             void tst_QValueAxis::max_raw()
             {
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_valuesaxis->setMax(max);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), max), "Not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QValueAxis::max_data()
             {
                 max_raw_data();
             }
             void tst_QValueAxis::max()
             {
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 max_raw();
             }
             void tst_QValueAxis::max_animation_data()
             {
                 max_data();
             }
             void tst_QValueAxis::max_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 max();
             }
             void tst_QValueAxis::min_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::newRow("-1.0") << (qreal)-1.0;
                 QTest::newRow("-50.0") << (qreal)-50.0;
                 QTest::newRow("-101.0") << (qreal)-101.0;
             }
             void tst_QValueAxis::min_raw()
             {
                 QFETCH(qreal, min);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_valuesaxis->setMin(min);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), min), "Not equal");
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QValueAxis::min_data()
             {
                 min_raw_data();
             }
             void tst_QValueAxis::min()
             {
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 min_raw();
             }
             void tst_QValueAxis::min_animation_data()
             {
                 min_data();
             }
             void tst_QValueAxis::min_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 min();
             }
             void tst_QValueAxis::niceNumbersEnabled_data()
             {
                 QTest::addColumn<bool>("niceNumbersEnabled");
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::addColumn<int>("ticks");
                 QTest::addColumn<qreal>("expectedMin");
                 QTest::addColumn<qreal>("expectedMax");
                 QTest::addColumn<int>("expectedTicks");
                 QTest::newRow("true 0.1 , 99.0 , 5") << true << (qreal)0.1 << (qreal)99.0 << 5 << (qreal)0.0 << (qreal)100.0 << 6;
                 QTest::newRow("true 1 , 10.0 , 5") << true << (qreal)1.0 << (qreal)10.0 << 5 << (qreal)0.0 << (qreal)10.0 << 6;
                 QTest::newRow("true 0.1 , 6.6 , 5") << true << (qreal)0.1 << (qreal)6.6 << 5 << (qreal)0.0 << (qreal)8.0 << 5;
                 QTest::newRow("false 0.1 , 6.6 , 5") << false << (qreal)0.1 << (qreal)6.6 << 5 << (qreal)0.1 << (qreal)6.6 << 5;
                 QTest::newRow("true 0.1, 99, 5") << true << (qreal)0.1 << (qreal)99.0 << 5 << (qreal)0.0 << (qreal)100.0 << 6;
                 QTest::newRow("true 5, 93.5 , 5") << true << (qreal)5.0 << (qreal)93.5 << 5 << (qreal)0.0 << (qreal)100.0 << 6;
             }
             void tst_QValueAxis::niceNumbersEnabled()
             {
                 QFETCH(bool, niceNumbersEnabled);
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QFETCH(int, ticks);
                 QFETCH(qreal, expectedMin);
                 QFETCH(qreal, expectedMax);
                 QFETCH(int, expectedTicks);
                 m_valuesaxis->setRange(min, max);
                 m_valuesaxis->setTickCount(ticks);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), min), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), max), "Max not equal");
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_valuesaxis->setNiceNumbersEnabled(niceNumbersEnabled);
                 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), niceNumbersEnabled);
-                if(!qFuzzyIsNull(expectedMin - min))
+                if(!qFuzzyCompare(expectedMin, min))
                     QCOMPARE(spy1.count(), 1);
-                if(!qFuzzyIsNull(expectedMax - max))
+                if(!qFuzzyCompare(expectedMax, max))
                     QCOMPARE(spy0.count(), 1);
-                if((!qFuzzyIsNull(expectedMin - min)) || (!qFuzzyIsNull(expectedMax - max)))
+                if((!qFuzzyCompare(expectedMin, min)) || (!qFuzzyCompare(expectedMax, max)))
                     QCOMPARE(spy2.count(), 1);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - expectedMin), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), expectedMin), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - expectedMax), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), expectedMax), "Max not equal");
                 QCOMPARE(m_valuesaxis->tickCount(), expectedTicks);
             }
             void tst_QValueAxis::range_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0 - 101.0") << (qreal)-1.0 << (qreal)101.0;
                 QTest::newRow("25.0 - 75.0") << (qreal)25.0 << (qreal)75.0;
                 QTest::newRow("101.0") << (qreal)40.0 << (qreal)60.0;
             }
             void tst_QValueAxis::range_raw()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_valuesaxis->setRange(min, max);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), min), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QValueAxis::range_data()
             {
                 range_raw_data();
             }
             void tst_QValueAxis::range()
             {
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 range_raw();
             }
             void tst_QValueAxis::range_animation_data()
             {
                 range_data();
             }
             void tst_QValueAxis::range_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 range();
             }
             void tst_QValueAxis::ticksCount_data()
             {
                 QTest::addColumn<int>("ticksCount");
                 QTest::addColumn<int>("expectedCount");
                 QTest::newRow("0") << 2;
                 QTest::newRow("1") << 2;
                 QTest::newRow("2") << 2;
                 QTest::newRow("3") << 3;
                 QTest::newRow("-1") << 2;
             }
             void tst_QValueAxis::ticksCount()
             {
                 QFETCH(int, ticksCount);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_valuesaxis->setTickCount(ticksCount);
                 QCOMPARE(m_valuesaxis->tickCount(), ticksCount);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_valuesaxis->tickCount(), ticksCount);
             }
             void tst_QValueAxis::noautoscale_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0 - 101.0") << (qreal)-1.0 << (qreal)101.0;
                 QTest::newRow("25.0 - 75.0") << (qreal)25.0 << (qreal)75.0;
                 QTest::newRow("101.0") << (qreal)40.0 << (qreal)60.0;
             }
             void tst_QValueAxis::noautoscale()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_valuesaxis->setRange(min, max);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), min), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), min), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), max), "Max not equal");
             }
             void tst_QValueAxis::autoscale_data()
             {
             }
             void tst_QValueAxis::autoscale()
             {
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min()), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), 0), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max()), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), 0), "Max not equal");
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() + 100), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), -100), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - 100), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), 100), "Max not equal");
             }
             QTEST_MAIN(tst_QValueAxis)
             #include "tst_qvalueaxis.moc"

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