Rename qIsFuzzyNull to qFuzzyIsNull

The function was added in fde7f3d03782c801901f511131458d6fcb1021a5
and we believe qFuzzyIsNull is a better naming and more in line
with qFuzzyCompare.

Reviewed-by: Lars Knoll
Reviewed-by: nrc
Reviewed-by: Samuel

23 files changed, 112 insertions, 112 deletions

diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index 28b9d08..5fd05c0 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -1709,7 +1709,7 @@ static inline bool qFuzzyCompare(float p1, float p2)
 /*!
   \internal
 */
-static inline bool qIsFuzzyNull(double d)
+static inline bool qFuzzyIsNull(double d)
 {
     return qAbs(d) <= 0.000000000001;
 }
@@ -1717,7 +1717,7 @@ static inline bool qIsFuzzyNull(double d)
 /*!
   \internal
 */
-static inline bool qIsFuzzyNull(float f)
+static inline bool qFuzzyIsNull(float f)
 {
     return qAbs(f) <= 0.00001f;
 }
diff --git a/src/corelib/tools/qsize.h b/src/corelib/tools/qsize.h
index df2c183..34a6c99 100644
--- a/src/corelib/tools/qsize.h
+++ b/src/corelib/tools/qsize.h
@@ -171,14 +171,14 @@ inline const QSize operator*(qreal c, const QSize &s)
 
 inline QSize &QSize::operator/=(qreal c)
 {
-    Q_ASSERT(!qIsFuzzyNull(c));
+    Q_ASSERT(!qFuzzyIsNull(c));
     wd = qRound(wd/c); ht = qRound(ht/c);
     return *this;
 }
 
 inline const QSize operator/(const QSize &s, qreal c)
 {
-    Q_ASSERT(!qIsFuzzyNull(c));
+    Q_ASSERT(!qFuzzyIsNull(c));
     return QSize(qRound(s.wd/c), qRound(s.ht/c));
 }
 
@@ -327,14 +327,14 @@ inline const QSizeF operator*(qreal c, const QSizeF &s)
 
 inline QSizeF &QSizeF::operator/=(qreal c)
 {
-    Q_ASSERT(!qIsFuzzyNull(c));
+    Q_ASSERT(!qFuzzyIsNull(c));
     wd = wd/c; ht = ht/c;
     return *this;
 }
 
 inline const QSizeF operator/(const QSizeF &s, qreal c)
 {
-    Q_ASSERT(!qIsFuzzyNull(c));
+    Q_ASSERT(!qFuzzyIsNull(c));
     return QSizeF(s.wd/c, s.ht/c);
 }
 
diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index 0d846d9..e7f9bd3 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -1906,11 +1906,11 @@ void QGraphicsItem::setOpacity(qreal opacity)
     newOpacity = qBound<qreal>(0.0, newOpacity, 1.0);
 
     // No change? Done.
-    if (qIsFuzzyNull(newOpacity - this->opacity()))
+    if (qFuzzyIsNull(newOpacity - this->opacity()))
         return;
 
     // Assign local opacity.
-    if (qIsFuzzyNull(newOpacity - 1)) {
+    if (qFuzzyIsNull(newOpacity - 1)) {
         // Opaque, unset opacity.
         d_ptr->hasOpacity = 0;
         d_ptr->unsetExtra(QGraphicsItemPrivate::ExtraOpacity);
@@ -3771,7 +3771,7 @@ void QGraphicsItemPrivate::resolveEffectiveOpacity(qreal parentEffectiveOpacity)
     }
 
     // Set this item's resolved opacity.
-    if (qIsFuzzyNull(myEffectiveOpacity - 1)) {
+    if (qFuzzyIsNull(myEffectiveOpacity - 1)) {
         // Opaque, unset effective opacity.
         hasEffectiveOpacity = 0;
         unsetExtra(ExtraEffectiveOpacity);
@@ -4091,7 +4091,7 @@ void QGraphicsItem::scroll(qreal dx, qreal dy, const QRectF &rect)
         return;
     if (d->cacheMode != NoCache) {
         QGraphicsItemCache *c;
-        bool scrollCache = qIsFuzzyNull(dx - int(dx)) && qIsFuzzyNull(dy - int(dy))
+        bool scrollCache = qFuzzyIsNull(dx - int(dx)) && qFuzzyIsNull(dy - int(dy))
                            && (c = (QGraphicsItemCache *)qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraCacheData)))
                            && (d->cacheMode == ItemCoordinateCache && !c->fixedSize.isValid());
         if (scrollCache) {
@@ -5854,7 +5854,7 @@ static void qt_graphicsItem_highlightSelected(
     QGraphicsItem *item, QPainter *painter, const QStyleOptionGraphicsItem *option)
 {
     const QRectF murect = painter->transform().mapRect(QRectF(0, 0, 1, 1));
-    if (qIsFuzzyNull(qMax(murect.width(), murect.height())))
+    if (qFuzzyIsNull(qMax(murect.width(), murect.height())))
         return;
 
     const QRectF mbrect = painter->transform().mapRect(item->boundingRect());
diff --git a/src/gui/graphicsview/qgraphicsitem_p.h b/src/gui/graphicsview/qgraphicsitem_p.h
index 77db691..078c543 100644
--- a/src/gui/graphicsview/qgraphicsitem_p.h
+++ b/src/gui/graphicsview/qgraphicsitem_p.h
@@ -269,7 +269,7 @@ public:
     void updateCachedClipPathFromSetPosHelper(const QPointF &newPos);
 
     inline bool isFullyTransparent() const
-    { return hasEffectiveOpacity && qIsFuzzyNull(q_func()->effectiveOpacity()); }
+    { return hasEffectiveOpacity && qFuzzyIsNull(q_func()->effectiveOpacity()); }
 
     inline bool childrenCombineOpacity() const
     { return allChildrenCombineOpacity || children.isEmpty(); }
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index e885238..bd66c3d 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -4642,7 +4642,7 @@ static void _q_paintItem(QGraphicsItem *item, QPainter *painter,
                                 ? proxy->widget()->windowOpacity() : 1.0;
     const qreal oldPainterOpacity = painter->opacity();
 
-    if (qIsFuzzyNull(windowOpacity))
+    if (qFuzzyIsNull(windowOpacity))
         return;
     // Set new painter opacity.
     if (windowOpacity < 1.0)
@@ -5282,7 +5282,7 @@ void QGraphicsScene::itemUpdated(QGraphicsItem *item, const QRectF &rect)
     // Deliver the actual update.
     if (!d->updateAll) {
         if (d->views.isEmpty() || ((d->connectedSignals & d->changedSignalMask) && !item->d_ptr->itemIsUntransformable()
-                                   && qIsFuzzyNull(item->boundingRegionGranularity()))) {
+                                   && qFuzzyIsNull(item->boundingRegionGranularity()))) {
             // This block of code is kept for compatibility. Since 4.5, by default
             // QGraphicsView does not connect the signal and we use the below
             // method of delivering updates.
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index 623ba59..3e25ffc 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -4780,7 +4780,7 @@ void QWidget::render(QPainter *painter, const QPoint &targetOffset,
     }
 
     const qreal opacity = painter->opacity();
-    if (qIsFuzzyNull(opacity))
+    if (qFuzzyIsNull(opacity))
         return; // Fully transparent.
 
     Q_D(QWidget);
diff --git a/src/gui/math3d/qmatrix4x4.cpp b/src/gui/math3d/qmatrix4x4.cpp
index 1457400..e00d772 100644
--- a/src/gui/math3d/qmatrix4x4.cpp
+++ b/src/gui/math3d/qmatrix4x4.cpp
@@ -1514,7 +1514,7 @@ void QMatrix4x4::extractAxisRotation(qreal &angle, QVector3D &axis) const
     angle = acos(cosa) * 180.0f / M_PI;
 
     // Any axis will work if r is zero (means no rotation)
-    if (qIsFuzzyNull(angle)) {
+    if (qFuzzyIsNull(angle)) {
         axis.setX(1.0f);
         axis.setY(0.0f);
         axis.setZ(0.0f);
diff --git a/src/gui/painting/qbezier.cpp b/src/gui/painting/qbezier.cpp
index 1168b5a..7ed521e 100644
--- a/src/gui/painting/qbezier.cpp
+++ b/src/gui/painting/qbezier.cpp
@@ -127,13 +127,13 @@ static inline void flattenBezierWithoutInflections(QBezier &bez,
         qreal dy = bez.y2 - bez.y1;
 
         qreal normalized = qSqrt(dx * dx + dy * dy);
-        if (qIsFuzzyNull(normalized))
+        if (qFuzzyIsNull(normalized))
            break;
 
         qreal d = qAbs(dx * (bez.y3 - bez.y2) - dy * (bez.x3 - bez.x2));
 
         qreal t = qSqrt(4. / 3. * normalized * flatness / d);
-        if (t > 1 || qIsFuzzyNull(t - (qreal)1.))
+        if (t > 1 || qFuzzyIsNull(t - (qreal)1.))
             break;
         bez.parameterSplitLeft(t, &left);
         p->append(bez.pt1());
@@ -144,19 +144,19 @@ static inline void flattenBezierWithoutInflections(QBezier &bez,
 static inline int quadraticRoots(qreal a, qreal b, qreal c,
                                  qreal *x1, qreal *x2)
 {
-    if (qIsFuzzyNull(a)) {
-        if (qIsFuzzyNull(b))
+    if (qFuzzyIsNull(a)) {
+        if (qFuzzyIsNull(b))
             return 0;
         *x1 = *x2 = (-c / b);
         return 1;
     } else {
         const qreal det = b * b - 4 * a * c;
-        if (qIsFuzzyNull(det)) {
+        if (qFuzzyIsNull(det)) {
             *x1 = *x2 = -b / (2 * a);
             return 1;
         }
         if (det > 0) {
-            if (qIsFuzzyNull(b)) {
+            if (qFuzzyIsNull(b)) {
                 *x2 = qSqrt(-c / a);
                 *x1 = -(*x2);
                 return 2;
@@ -187,7 +187,7 @@ static inline bool findInflections(qreal a, qreal b, qreal c,
             *t1 = r2;
             *t2 = r1;
         }
-        if (!qIsFuzzyNull(a))
+        if (!qFuzzyIsNull(a))
             *tCups = 0.5 * (-b / a);
         else
             *tCups = 2;
@@ -243,7 +243,7 @@ void QBezier::addToPolygonMixed(QPolygonF *polygon) const
     qreal b = 6 * (ay * cx - ax * cy);
     qreal c = 2 * (by * cx - bx * cy);
 
-    if ((qIsFuzzyNull(a) && qIsFuzzyNull(b)) ||
+    if ((qFuzzyIsNull(a) && qFuzzyIsNull(b)) ||
         (b * b - 4 * a *c) < 0) {
         QBezier bez(*this);
         flattenBezierWithoutInflections(bez, polygon);
@@ -447,7 +447,7 @@ static ShiftResult shift(const QBezier *orig, QBezier *shifted, qreal offset, qr
         qreal r = 1.0 + prev_normal.x() * next_normal.x()
                   + prev_normal.y() * next_normal.y();
 
-        if (qIsFuzzyNull(r)) {
+        if (qFuzzyIsNull(r)) {
             points_shifted[i] = points[i] + offset * prev_normal;
         } else {
             qreal k = offset / r;
@@ -477,12 +477,12 @@ static bool addCircle(const QBezier *b, qreal offset, QBezier *o)
 
     normals[0] = QPointF(b->y2 - b->y1, b->x1 - b->x2);
     qreal dist = qSqrt(normals[0].x()*normals[0].x() + normals[0].y()*normals[0].y());
-    if (qIsFuzzyNull(dist))
+    if (qFuzzyIsNull(dist))
         return false;
     normals[0] /= dist;
     normals[2] = QPointF(b->y4 - b->y3, b->x3 - b->x4);
     dist = qSqrt(normals[2].x()*normals[2].x() + normals[2].y()*normals[2].y());
-    if (qIsFuzzyNull(dist))
+    if (qFuzzyIsNull(dist))
         return false;
     normals[2] /= dist;
 
@@ -1022,7 +1022,7 @@ int QBezier::stationaryYPoints(qreal &t0, qreal &t1) const
 
     QList<qreal> result;
 
-    if (qIsFuzzyNull(reciprocal)) {
+    if (qFuzzyIsNull(reciprocal)) {
         t0 = -b / (2 * a);
         return 1;
     } else if (reciprocal > 0) {
diff --git a/src/gui/painting/qcolor.cpp b/src/gui/painting/qcolor.cpp
index 6eecea0..24d167e 100644
--- a/src/gui/painting/qcolor.cpp
+++ b/src/gui/painting/qcolor.cpp
@@ -1387,7 +1387,7 @@ QColor QColor::toHsv() const
     const qreal min = Q_MIN_3(r, g, b);
     const qreal delta = max - min;
     color.ct.ahsv.value = qRound(max * USHRT_MAX);
-    if (qIsFuzzyNull(delta)) {
+    if (qFuzzyIsNull(delta)) {
         // achromatic case, hue is undefined
         color.ct.ahsv.hue = USHRT_MAX;
         color.ct.ahsv.saturation = 0;
@@ -1441,7 +1441,7 @@ QColor QColor::toCmyk() const
     // cmy -> cmyk
     const qreal k = qMin(c, qMin(m, y));
 
-    if (!qIsFuzzyNull(k - 1)) {
+    if (!qFuzzyIsNull(k - 1)) {
         c = (c - k) / (1.0 - k);
         m = (m - k) / (1.0 - k);
         y = (y - k) / (1.0 - k);
diff --git a/src/gui/painting/qmatrix.h b/src/gui/painting/qmatrix.h
index 71c1e34..1e5fbb4 100644
--- a/src/gui/painting/qmatrix.h
+++ b/src/gui/painting/qmatrix.h
@@ -99,7 +99,7 @@ public:
     QMatrix &shear(qreal sh, qreal sv);
     QMatrix &rotate(qreal a);
 
-    bool isInvertible() const { return !qIsFuzzyNull(_m11*_m22 - _m12*_m21); }
+    bool isInvertible() const { return !qFuzzyIsNull(_m11*_m22 - _m12*_m21); }
     qreal det() const { return _m11*_m22 - _m12*_m21; }
 
     QMatrix inverted(bool *invertible = 0) const;
@@ -161,8 +161,8 @@ Q_GUI_EXPORT QPainterPath operator *(const QPainterPath &p, const QMatrix &m);
 
 inline bool QMatrix::isIdentity() const
 {
-    return qIsFuzzyNull(_m11 - 1) && qIsFuzzyNull(_m22 - 1) && qIsFuzzyNull(_m12)
-           && qIsFuzzyNull(_m21) && qIsFuzzyNull(_dx) && qIsFuzzyNull(_dy);
+    return qFuzzyIsNull(_m11 - 1) && qFuzzyIsNull(_m22 - 1) && qFuzzyIsNull(_m12)
+           && qFuzzyIsNull(_m21) && qFuzzyIsNull(_dx) && qFuzzyIsNull(_dy);
 }
 
 /*****************************************************************************
diff --git a/src/gui/painting/qpaintengine_d3d.cpp b/src/gui/painting/qpaintengine_d3d.cpp
index 4b494d1..9a7638b 100644
--- a/src/gui/painting/qpaintengine_d3d.cpp
+++ b/src/gui/painting/qpaintengine_d3d.cpp
@@ -2506,8 +2506,8 @@ void QD3DDrawHelper::addTrap(const Trapezoid &trap)
     qreal _rightA = (qreal)_w/_h;
     qreal _rightB = topRightX - _rightA * topRightY;
 
-    qreal invLeftA = qIsFuzzyNull(_leftA) ? 0.0 : 1.0 / _leftA;
-    qreal invRightA = qIsFuzzyNull(_rightA) ? 0.0 : 1.0 / _rightA;
+    qreal invLeftA = qFuzzyIsNull(_leftA) ? 0.0 : 1.0 / _leftA;
+    qreal invRightA = qFuzzyIsNull(_rightA) ? 0.0 : 1.0 / _rightA;
 
     vertex v1 = { {1.f, top - 1.f, 0.5f}, 0.f,
         top, bottom, invLeftA, -invRightA,
@@ -2970,7 +2970,7 @@ qreal calculateAngle(qreal dx, qreal dy)
 {
     qreal angle;
 
-    if (qIsFuzzyNull(dx)) {
+    if (qFuzzyIsNull(dx)) {
         angle = (dy < 0) ? -M_PI/2 : M_PI/2;
     } else {
         angle = atanf(dy/dx);
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index 7aab25c..92160f9 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -618,22 +618,22 @@ void QRasterPaintEngine::updateMatrix(const QTransform &matrix)
     d->isPlain45DegreeRotation = false;
     if (txop >= QTransform::TxRotate) {
         d->isPlain45DegreeRotation =
-            (qIsFuzzyNull(matrix.m11())
-             && qIsFuzzyNull(matrix.m12() - qreal(1))
-             && qIsFuzzyNull(matrix.m21() + qreal(1))
-             && qIsFuzzyNull(matrix.m22())
+            (qFuzzyIsNull(matrix.m11())
+             && qFuzzyIsNull(matrix.m12() - qreal(1))
+             && qFuzzyIsNull(matrix.m21() + qreal(1))
+             && qFuzzyIsNull(matrix.m22())
                 )
             ||
-            (qIsFuzzyNull(matrix.m11() + qreal(1))
-             && qIsFuzzyNull(matrix.m12())
-             && qIsFuzzyNull(matrix.m21())
-             && qIsFuzzyNull(matrix.m22() + qreal(1))
+            (qFuzzyIsNull(matrix.m11() + qreal(1))
+             && qFuzzyIsNull(matrix.m12())
+             && qFuzzyIsNull(matrix.m21())
+             && qFuzzyIsNull(matrix.m22() + qreal(1))
                 )
             ||
-            (qIsFuzzyNull(matrix.m11())
-             && qIsFuzzyNull(matrix.m12() + qreal(1))
-             && qIsFuzzyNull(matrix.m21() - qreal(1))
-             && qIsFuzzyNull(matrix.m22())
+            (qFuzzyIsNull(matrix.m11())
+             && qFuzzyIsNull(matrix.m12() + qreal(1))
+             && qFuzzyIsNull(matrix.m21() - qreal(1))
+             && qFuzzyIsNull(matrix.m22())
                 )
             ;
     }
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index d4271ae..133520e 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -6055,22 +6055,22 @@ void QPainter::drawTextItem(const QPointF &p, const QTextItem &_ti)
         const QTransform &m = d->state->matrix;
         if (d->state->matrix.type() < QTransform::TxShear) {
             bool isPlain90DegreeRotation =
-                (qIsFuzzyNull(m.m11())
-                 && qIsFuzzyNull(m.m12() - qreal(1))
-                 && qIsFuzzyNull(m.m21() + qreal(1))
-                 && qIsFuzzyNull(m.m22())
+                (qFuzzyIsNull(m.m11())
+                 && qFuzzyIsNull(m.m12() - qreal(1))
+                 && qFuzzyIsNull(m.m21() + qreal(1))
+                 && qFuzzyIsNull(m.m22())
                     )
                 ||
-                (qIsFuzzyNull(m.m11() + qreal(1))
-                 && qIsFuzzyNull(m.m12())
-                 && qIsFuzzyNull(m.m21())
-                 && qIsFuzzyNull(m.m22() + qreal(1))
+                (qFuzzyIsNull(m.m11() + qreal(1))
+                 && qFuzzyIsNull(m.m12())
+                 && qFuzzyIsNull(m.m21())
+                 && qFuzzyIsNull(m.m22() + qreal(1))
                     )
                 ||
-                (qIsFuzzyNull(m.m11())
-                 && qIsFuzzyNull(m.m12() + qreal(1))
-                 && qIsFuzzyNull(m.m21() - qreal(1))
-                 && qIsFuzzyNull(m.m22())
+                (qFuzzyIsNull(m.m11())
+                 && qFuzzyIsNull(m.m12() + qreal(1))
+                 && qFuzzyIsNull(m.m21() - qreal(1))
+                 && qFuzzyIsNull(m.m22())
                     )
                 ;
             aa = !isPlain90DegreeRotation;
diff --git a/src/gui/painting/qpainterpath.cpp b/src/gui/painting/qpainterpath.cpp
index de8969c..d471aaa 100644
--- a/src/gui/painting/qpainterpath.cpp
+++ b/src/gui/painting/qpainterpath.cpp
@@ -1299,10 +1299,10 @@ static QRectF qt_painterpath_bezier_extrema(const QBezier &b)
         qreal bx = QT_BEZIER_B(b, x);
         qreal cx = QT_BEZIER_C(b, x);
         // specialcase quadratic curves to avoid div by zero
-        if (qIsFuzzyNull(ax)) {
+        if (qFuzzyIsNull(ax)) {
 
             // linear curves are covered by initialization.
-            if (!qIsFuzzyNull(bx)) {
+            if (!qFuzzyIsNull(bx)) {
                 qreal t = -cx / bx;
                 QT_BEZIER_CHECK_T(b, t);
             }
@@ -1329,10 +1329,10 @@ static QRectF qt_painterpath_bezier_extrema(const QBezier &b)
         qreal cy = QT_BEZIER_C(b, y);
 
         // specialcase quadratic curves to avoid div by zero
-        if (qIsFuzzyNull(ay)) {
+        if (qFuzzyIsNull(ay)) {
 
             // linear curves are covered by initialization.
-            if (!qIsFuzzyNull(by)) {
+            if (!qFuzzyIsNull(by)) {
                 qreal t = -cy / by;
                 QT_BEZIER_CHECK_T(b, t);
             }
diff --git a/src/gui/painting/qpathclipper.cpp b/src/gui/painting/qpathclipper.cpp
index 33609ad..9ef3eb7 100644
--- a/src/gui/painting/qpathclipper.cpp
+++ b/src/gui/painting/qpathclipper.cpp
@@ -138,11 +138,11 @@ bool QIntersectionFinder::linesIntersect(const QLineF &a, const QLineF &b) const
 
     const qreal par = pDelta.x() * qDelta.y() - pDelta.y() * qDelta.x();
 
-    if (qIsFuzzyNull(par)) {
+    if (qFuzzyIsNull(par)) {
         const QPointF normal(-pDelta.y(), pDelta.x());
 
         // coinciding?
-        if (qIsFuzzyNull(dot(normal, q1 - p1))) {
+        if (qFuzzyIsNull(dot(normal, q1 - p1))) {
             const qreal dp = dot(pDelta, pDelta);
 
             const qreal tq1 = dot(pDelta, q1 - p1);
@@ -202,13 +202,13 @@ void QIntersectionFinder::intersectBeziers(const QBezier &one, const QBezier &tw
         qreal alpha_q = t.at(i).second;
 
         QPointF pt;
-        if (qIsFuzzyNull(alpha_p)) {
+        if (qFuzzyIsNull(alpha_p)) {
             pt = one.pt1();
-        } else if (qIsFuzzyNull(alpha_p - 1)) {
+        } else if (qFuzzyIsNull(alpha_p - 1)) {
             pt = one.pt4();
-        } else if (qIsFuzzyNull(alpha_q)) {
+        } else if (qFuzzyIsNull(alpha_q)) {
             pt = two.pt1();
-        } else if (qIsFuzzyNull(alpha_q - 1)) {
+        } else if (qFuzzyIsNull(alpha_q - 1)) {
             pt = two.pt4();
         } else {
             pt = one.pointAt(alpha_p);
@@ -250,11 +250,11 @@ void QIntersectionFinder::intersectLines(const QLineF &a, const QLineF &b, QData
 
     const qreal par = pDelta.x() * qDelta.y() - pDelta.y() * qDelta.x();
 
-    if (qIsFuzzyNull(par)) {
+    if (qFuzzyIsNull(par)) {
         const QPointF normal(-pDelta.y(), pDelta.x());
 
         // coinciding?
-        if (qIsFuzzyNull(dot(normal, q1 - p1))) {
+        if (qFuzzyIsNull(dot(normal, q1 - p1))) {
             const qreal invDp = 1 / dot(pDelta, pDelta);
 
             const qreal tq1 = dot(pDelta, q1 - p1) * invDp;
@@ -315,11 +315,11 @@ void QIntersectionFinder::intersectLines(const QLineF &a, const QLineF &b, QData
     if (tp<0 || tp>1 || tq<0 || tq>1)
         return;
 
-    const bool p_zero = qIsFuzzyNull(tp);
-    const bool p_one = qIsFuzzyNull(tp - 1);
+    const bool p_zero = qFuzzyIsNull(tp);
+    const bool p_one = qFuzzyIsNull(tp - 1);
 
-    const bool q_zero = qIsFuzzyNull(tq);
-    const bool q_one = qIsFuzzyNull(tq - 1);
+    const bool q_zero = qFuzzyIsNull(tq);
+    const bool q_one = qFuzzyIsNull(tq - 1);
 
     if ((q_zero || q_one) && (p_zero || p_one))
         return;
@@ -922,7 +922,7 @@ qreal QWingedEdge::delta(int vertex, int a, int b) const
 
     qreal result = b_angle - a_angle;
 
-    if (qIsFuzzyNull(result) || qFuzzyCompare(result, 128))
+    if (qFuzzyIsNull(result) || qFuzzyCompare(result, 128))
         return 0;
 
     if (result < 0)
@@ -951,7 +951,7 @@ static inline QPointF tangentAt(const QWingedEdge &list, int vi, int ei)
     if (ep->bezier) {
         normal = ep->bezier->derivedAt(t);
 
-        if (qIsFuzzyNull(normal.x()) && qIsFuzzyNull(normal.y()))
+        if (qFuzzyIsNull(normal.x()) && qFuzzyIsNull(normal.y()))
             normal = ep->bezier->secondDerivedAt(t);
     } else {
         const QPointF a = *list.vertex(ep->first);
@@ -1080,7 +1080,7 @@ QWingedEdge::TraversalStatus QWingedEdge::findInsertStatus(int vi, int ei) const
         qDebug() << "Delta to edge" << status.edge << d2 << ", angles: " << op->angle << op->invAngle;
 #endif
 
-        if (!(qIsFuzzyNull(d2) && isLeftOf(*this, vi, status.edge, ei))
+        if (!(qFuzzyIsNull(d2) && isLeftOf(*this, vi, status.edge, ei))
             && (d2 < d || (qFuzzyCompare(d2, d) && isLeftOf(*this, vi, status.edge, position)))) {
             position = status.edge;
             d = d2;
@@ -1232,10 +1232,10 @@ int QWingedEdge::addEdge(int fi, int si, const QBezier *bezier, qreal t0, qreal
         QPointF aTangent = bezier->derivedAt(t0);
         QPointF bTangent = -bezier->derivedAt(t1);
 
-        if (qIsFuzzyNull(aTangent.x()) && qIsFuzzyNull(aTangent.y()))
+        if (qFuzzyIsNull(aTangent.x()) && qFuzzyIsNull(aTangent.y()))
             aTangent = bezier->secondDerivedAt(t0);
 
-        if (qIsFuzzyNull(bTangent.x()) && qIsFuzzyNull(bTangent.y()))
+        if (qFuzzyIsNull(bTangent.x()) && qFuzzyIsNull(bTangent.y()))
             bTangent = bezier->secondDerivedAt(t1);
 
         ep->angle = computeAngle(aTangent);
@@ -1400,7 +1400,7 @@ static void addLineTo(QPainterPath &path, const QPointF &point)
 
             const QPointF p(-d1.y(), d1.x());
 
-            if (qIsFuzzyNull(dot(p, d2))) {
+            if (qFuzzyIsNull(dot(p, d2))) {
                 path.setElementPositionAt(elementCount - 1, point.x(), point.y());
                 return;
             }
diff --git a/src/gui/painting/qstroker.cpp b/src/gui/painting/qstroker.cpp
index 3a856d3..5fffc72 100644
--- a/src/gui/painting/qstroker.cpp
+++ b/src/gui/painting/qstroker.cpp
@@ -763,7 +763,7 @@ template <class Iterator> bool qt_stroke_side(Iterator *it,
 
 qreal qt_t_for_arc_angle(qreal angle)
 {
-    if (qIsFuzzyNull(angle))
+    if (qFuzzyIsNull(angle))
         return 0;
 
     if (qFuzzyCompare(angle, qreal(90)))
@@ -904,13 +904,13 @@ QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLengt
     }
 
     // avoid empty start segment
-    if (qIsFuzzyNull(startT - qreal(1))) {
+    if (qFuzzyIsNull(startT - qreal(1))) {
         startT = 0;
         startSegment += delta;
     }
 
     // avoid empty end segment
-    if (qIsFuzzyNull(endT)) {
+    if (qFuzzyIsNull(endT)) {
         endT = 1;
         endSegment -= delta;
     }
@@ -918,8 +918,8 @@ QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLengt
     startT = qt_t_for_arc_angle(startT * 90);
     endT = qt_t_for_arc_angle(endT * 90);
 
-    const bool splitAtStart = !qIsFuzzyNull(startT);
-    const bool splitAtEnd = !qIsFuzzyNull(endT - qreal(1));
+    const bool splitAtStart = !qFuzzyIsNull(startT);
+    const bool splitAtEnd = !qFuzzyIsNull(endT - qreal(1));
 
     const int end = endSegment + delta;
 
@@ -1018,7 +1018,7 @@ void QDashStroker::processCurrentSubpath()
         sumLength += dashes[i];
     }
 
-    if (qIsFuzzyNull(sumLength))
+    if (qFuzzyIsNull(sumLength))
         return;
 
     Q_ASSERT(dashCount > 0);
diff --git a/src/gui/painting/qtessellator.cpp b/src/gui/painting/qtessellator.cpp
index ae07565..ce5ab74 100644
--- a/src/gui/painting/qtessellator.cpp
+++ b/src/gui/painting/qtessellator.cpp
@@ -1436,7 +1436,7 @@ void QTessellator::tessellateRect(const QPointF &a_, const QPointF &b_, qreal wi
         QPointF perp(pb.y() - pa.y(), pa.x() - pb.x());
         qreal length = qSqrt(perp.x() * perp.x() + perp.y() * perp.y());
 
-        if (qIsFuzzyNull(length))
+        if (qFuzzyIsNull(length))
             return;
 
         // need the half of the width
diff --git a/src/gui/painting/qtransform.cpp b/src/gui/painting/qtransform.cpp
index 6c37ab6..dfcca63 100644
--- a/src/gui/painting/qtransform.cpp
+++ b/src/gui/painting/qtransform.cpp
@@ -353,8 +353,8 @@ QTransform QTransform::inverted(bool *invertible) const
         invert.affine._dy = -affine._dy;
         break;
     case TxScale:
-        inv = !qIsFuzzyNull(affine._m11);
-        inv &= !qIsFuzzyNull(affine._m22);
+        inv = !qFuzzyIsNull(affine._m11);
+        inv &= !qFuzzyIsNull(affine._m22);
         if (inv) {
             invert.affine._m11 = 1. / affine._m11;
             invert.affine._m22 = 1. / affine._m22;
@@ -369,7 +369,7 @@ QTransform QTransform::inverted(bool *invertible) const
     default:
         // general case
         qreal det = determinant();
-        inv = !qIsFuzzyNull(det);
+        inv = !qFuzzyIsNull(det);
         if (inv)
             invert = adjoint() / det;
         break;
@@ -1958,27 +1958,27 @@ QTransform::TransformationType QTransform::type() const
 
     switch (static_cast<TransformationType>(m_dirty)) {
     case TxProject:
-        if (!qIsFuzzyNull(m_13) || !qIsFuzzyNull(m_23) || !qIsFuzzyNull(m_33 - 1)) {
+        if (!qFuzzyIsNull(m_13) || !qFuzzyIsNull(m_23) || !qFuzzyIsNull(m_33 - 1)) {
              m_type = TxProject;
              break;
          }
     case TxShear:
     case TxRotate:
-        if (!qIsFuzzyNull(affine._m12) || !qIsFuzzyNull(affine._m21)) {
+        if (!qFuzzyIsNull(affine._m12) || !qFuzzyIsNull(affine._m21)) {
             const qreal dot = affine._m11 * affine._m12 + affine._m21 * affine._m22;
-            if (qIsFuzzyNull(dot))
+            if (qFuzzyIsNull(dot))
                 m_type = TxRotate;
             else
                 m_type = TxShear;
             break;
         }
     case TxScale:
-        if (!qIsFuzzyNull(affine._m11 - 1) || !qIsFuzzyNull(affine._m22 - 1)) {
+        if (!qFuzzyIsNull(affine._m11 - 1) || !qFuzzyIsNull(affine._m22 - 1)) {
             m_type = TxScale;
             break;
         }
     case TxTranslate:
-        if (!qIsFuzzyNull(affine._dx) || !qIsFuzzyNull(affine._dy)) {
+        if (!qFuzzyIsNull(affine._dx) || !qFuzzyIsNull(affine._dy)) {
             m_type = TxTranslate;
             break;
         }
diff --git a/src/gui/painting/qtransform.h b/src/gui/painting/qtransform.h
index 2d6c889..aac7c31 100644
--- a/src/gui/painting/qtransform.h
+++ b/src/gui/painting/qtransform.h
@@ -204,7 +204,7 @@ inline bool QTransform::isIdentity() const
 
 inline bool QTransform::isInvertible() const
 {
-    return !qIsFuzzyNull(determinant());
+    return !qFuzzyIsNull(determinant());
 }
 
 inline bool QTransform::isScaling() const
diff --git a/src/opengl/qpaintengine_opengl.cpp b/src/opengl/qpaintengine_opengl.cpp
index 11df590..4afc621 100644
--- a/src/opengl/qpaintengine_opengl.cpp
+++ b/src/opengl/qpaintengine_opengl.cpp
@@ -1924,15 +1924,15 @@ static void drawTrapezoid(const QGLTrapezoid &trap, const qreal offscreenHeight,
     qreal leftB = trap.bottomLeftX + (trap.topLeftX - trap.bottomLeftX) * reciprocal;
     qreal rightB = trap.bottomRightX + (trap.topRightX - trap.bottomRightX) * reciprocal;
 
-    const bool topZero = qIsFuzzyNull(topDist);
+    const bool topZero = qFuzzyIsNull(topDist);
 
     reciprocal = topZero ? 1.0 / bottomDist : 1.0 / topDist;
 
     qreal leftA = topZero ? (trap.bottomLeftX - leftB) * reciprocal : (trap.topLeftX - leftB) * reciprocal;
     qreal rightA = topZero ? (trap.bottomRightX - rightB) * reciprocal : (trap.topRightX - rightB) * reciprocal;
 
-    qreal invLeftA = qIsFuzzyNull(leftA) ? 0.0 : 1.0 / leftA;
-    qreal invRightA = qIsFuzzyNull(rightA) ? 0.0 : 1.0 / rightA;
+    qreal invLeftA = qFuzzyIsNull(leftA) ? 0.0 : 1.0 / leftA;
+    qreal invRightA = qFuzzyIsNull(rightA) ? 0.0 : 1.0 / rightA;
 
     // fragment program needs the negative of invRightA as it mirrors the line
     glTexCoord4f(topDist, bottomDist, invLeftA, -invRightA);
@@ -3445,7 +3445,7 @@ QVector<QGLTrapezoid> QGLRectMaskGenerator::generateTrapezoids()
         // manhattan distance (no rotation)
         qreal width = qAbs(delta.x()) + qAbs(delta.y());
 
-        Q_ASSERT(qIsFuzzyNull(delta.x()) || qIsFuzzyNull(delta.y()));
+        Q_ASSERT(qFuzzyIsNull(delta.x()) || qFuzzyIsNull(delta.y()));
 
         tessellator.tessellateRect(first, last, width);
     } else {
diff --git a/src/svg/qgraphicssvgitem.cpp b/src/svg/qgraphicssvgitem.cpp
index 5c8a3c0..a14636e 100644
--- a/src/svg/qgraphicssvgitem.cpp
+++ b/src/svg/qgraphicssvgitem.cpp
@@ -186,7 +186,7 @@ static void qt_graphicsItem_highlightSelected(
     QGraphicsItem *item, QPainter *painter, const QStyleOptionGraphicsItem *option)
 {
     const QRectF murect = painter->transform().mapRect(QRectF(0, 0, 1, 1));
-    if (qIsFuzzyNull(qMax(murect.width(), murect.height())))
+    if (qFuzzyIsNull(qMax(murect.width(), murect.height())))
         return;
 
     const QRectF mbrect = painter->transform().mapRect(item->boundingRect());
diff --git a/src/svg/qsvggenerator.cpp b/src/svg/qsvggenerator.cpp
index 7c8926d..2b5fbd5 100644
--- a/src/svg/qsvggenerator.cpp
+++ b/src/svg/qsvggenerator.cpp
@@ -971,7 +971,7 @@ void QSvgPaintEngine::updateState(const QPaintEngineState &state)
     }
 
     if (flags & QPaintEngine::DirtyOpacity) {
-        if (!qIsFuzzyNull(state.opacity() - 1))
+        if (!qFuzzyIsNull(state.opacity() - 1))
             stream() << "opacity=\""<<state.opacity()<<"\" ";
     }
 
diff --git a/src/svg/qsvggraphics.cpp b/src/svg/qsvggraphics.cpp
index 709a2f7..1cd1f8b 100644
--- a/src/svg/qsvggraphics.cpp
+++ b/src/svg/qsvggraphics.cpp
@@ -94,7 +94,7 @@ QSvgCircle::QSvgCircle(QSvgNode *parent, const QRectF &rect)
 QRectF QSvgCircle::bounds() const
 {
     qreal sw = strokeWidth();
-    if (qIsFuzzyNull(sw))
+    if (qFuzzyIsNull(sw))
         return m_bounds;
     else {
         QPainterPath path;
@@ -129,7 +129,7 @@ QSvgEllipse::QSvgEllipse(QSvgNode *parent, const QRectF &rect)
 QRectF QSvgEllipse::bounds() const
 {
     qreal sw = strokeWidth();
-    if (qIsFuzzyNull(sw))
+    if (qFuzzyIsNull(sw))
         return m_bounds;
     else {
         QPainterPath path;
@@ -190,7 +190,7 @@ void QSvgPath::draw(QPainter *p, QSvgExtraStates &states)
 QRectF QSvgPath::bounds() const
 {
     qreal sw = strokeWidth();
-    if (qIsFuzzyNull(sw))
+    if (qFuzzyIsNull(sw))
         return m_cachedBounds;
     else {
         return boundsOnStroke(m_path, sw);
@@ -206,7 +206,7 @@ QSvgPolygon::QSvgPolygon(QSvgNode *parent, const QPolygonF &poly)
 QRectF QSvgPolygon::bounds() const
 {
     qreal sw = strokeWidth();
-    if (qIsFuzzyNull(sw))
+    if (qFuzzyIsNull(sw))
         return m_poly.boundingRect();
     else {
         QPainterPath path;
@@ -249,7 +249,7 @@ QSvgRect::QSvgRect(QSvgNode *node, const QRectF &rect, int rx, int ry)
 QRectF QSvgRect::bounds() const
 {
     qreal sw = strokeWidth();
-    if (qIsFuzzyNull(sw))
+    if (qFuzzyIsNull(sw))
         return m_rect;
     else {
         QPainterPath path;
@@ -596,7 +596,7 @@ QRectF QSvgUse::transformedBounds(const QTransform &transform) const
 QRectF QSvgPolyline::bounds() const
 {
     qreal sw = strokeWidth();
-    if (qIsFuzzyNull(sw))
+    if (qFuzzyIsNull(sw))
         return m_poly.boundingRect();
     else {
         QPainterPath path;
@@ -608,7 +608,7 @@ QRectF QSvgPolyline::bounds() const
 QRectF QSvgArc::bounds() const
 {
     qreal sw = strokeWidth();
-    if (qIsFuzzyNull(sw))
+    if (qFuzzyIsNull(sw))
         return m_cachedBounds;
     else {
         return boundsOnStroke(cubic, sw);
@@ -623,7 +623,7 @@ QRectF QSvgImage::bounds() const
 QRectF QSvgLine::bounds() const
 {
     qreal sw = strokeWidth();
-    if (qIsFuzzyNull(sw)) {
+    if (qFuzzyIsNull(sw)) {
         qreal minX = qMin(m_bounds.x1(), m_bounds.x2());
         qreal minY = qMin(m_bounds.y1(), m_bounds.y2());
         qreal maxX = qMax(m_bounds.x1(), m_bounds.x2());