Merge remote-tracking branch 'origin/5.12' into dev

 Conflicts:
	.qmake.conf
	src/gui/painting/qdrawhelper.cpp
	src/gui/text/qdistancefield.cpp
	src/gui/text/qdistancefield_p.h
	src/network/ssl/qsslsocket_openssl.cpp
	src/plugins/platforms/android/qandroidinputcontext.cpp
	src/widgets/styles/qstylesheetstyle.cpp

Done-With: Timur Pocheptsov <timur.pocheptsov@qt.io>
Change-Id: Ia7daad21f077ea889898f17734ec46303e71fe6b

12 files changed, 123 insertions, 255 deletions

diff --git a/src/gui/accessible/qaccessible.cpp b/src/gui/accessible/qaccessible.cpp
index 68e36de24b..db47a3abc1 100644
--- a/src/gui/accessible/qaccessible.cpp
+++ b/src/gui/accessible/qaccessible.cpp
@@ -350,6 +350,7 @@ Q_LOGGING_CATEGORY(lcAccessibilityCore, "qt.accessibility.core");
     \value MenuItem         An item in a menu or menu bar.
     \value NoRole           The object has no role. This usually indicates an invalid object.
     \value Note             A section whose content is parenthetic or ancillary to the main content of the resource.
+    \value Notification     An object that represents a notification (e.g. in the system tray). This role only has an effect on Linux.
     \value PageTab          A page tab that the user can select to switch to a different page in a dialog.
     \value PageTabList      A list of page tabs.
     \value Paragraph        A paragraph of text (usually found in documents).
diff --git a/src/gui/accessible/qaccessible.h b/src/gui/accessible/qaccessible.h
index e2163b06d0..2220efd5cb 100644
--- a/src/gui/accessible/qaccessible.h
+++ b/src/gui/accessible/qaccessible.h
@@ -299,6 +299,7 @@ public:
         Paragraph      = 0x00000083,
         WebDocument    = 0x00000084,
         Section        = 0x00000085,
+        Notification   = 0x00000086,
 
         // IAccessible2 roles
         // IA2_ROLE_CANVAS = 0x401, ### Qt 6 use this one instead of Canvas above
diff --git a/src/gui/image/qimagereader.cpp b/src/gui/image/qimagereader.cpp
index ae433ff651..2762b702b2 100644
--- a/src/gui/image/qimagereader.cpp
+++ b/src/gui/image/qimagereader.cpp
@@ -1321,10 +1321,12 @@ bool QImageReader::read(QImage *image)
         }
     }
 
-    // successful read; check for "@2x" file name suffix and set device pixel ratio.
-    static bool disable2xImageLoading = !qEnvironmentVariableIsEmpty("QT_HIGHDPI_DISABLE_2X_IMAGE_LOADING");
-    if (!disable2xImageLoading && QFileInfo(fileName()).baseName().endsWith(QLatin1String("@2x"))) {
-           image->setDevicePixelRatio(2.0);
+    // successful read; check for "@Nx" file name suffix and set device pixel ratio.
+    static bool disableNxImageLoading = !qEnvironmentVariableIsEmpty("QT_HIGHDPI_DISABLE_2X_IMAGE_LOADING");
+    if (!disableNxImageLoading) {
+        const QByteArray suffix = QFileInfo(fileName()).baseName().right(3).toLatin1();
+        if (suffix.length() == 3 && suffix[0] == '@' && suffix[1] >= '2' && suffix[1] <= '9' && suffix[2] == 'x')
+            image->setDevicePixelRatio(suffix[1] - '0');
     }
     if (autoTransform())
         qt_imageTransform(*image, transformation());
diff --git a/src/gui/kernel/qhighdpiscaling.cpp b/src/gui/kernel/qhighdpiscaling.cpp
index 4f8e9a3817..93fcb1a216 100644
--- a/src/gui/kernel/qhighdpiscaling.cpp
+++ b/src/gui/kernel/qhighdpiscaling.cpp
@@ -400,7 +400,7 @@ QPoint QHighDpiScaling::mapPositionToGlobal(const QPoint &pos, const QPoint &win
 QPoint QHighDpiScaling::mapPositionFromGlobal(const QPoint &pos, const QPoint &windowGlobalPosition, const QWindow *window)
 {
     QPoint windowPosCandidate = pos - windowGlobalPosition;
-    if (QGuiApplicationPrivate::screen_list.size() <= 1)
+    if (QGuiApplicationPrivate::screen_list.size() <= 1 || window->handle() == nullptr)
         return windowPosCandidate;
 
     // Device independent global (screen) space may discontiguous when high-dpi scaling
diff --git a/src/gui/kernel/qhighdpiscaling_p.h b/src/gui/kernel/qhighdpiscaling_p.h
index 91cfbcbfc7..6e89f85746 100644
--- a/src/gui/kernel/qhighdpiscaling_p.h
+++ b/src/gui/kernel/qhighdpiscaling_p.h
@@ -108,208 +108,114 @@ private:
 
 namespace QHighDpi {
 
-inline QPointF fromNative(const QPointF &pos, qreal scaleFactor, const QPointF &origin)
+template <typename T>
+inline T scale(const T &value, qreal scaleFactor, QPoint origin = QPoint(0, 0))
 {
-     return (pos - origin) / scaleFactor + origin;
+    Q_UNUSED(origin)
+    return value * scaleFactor;
 }
 
-inline QPointF toNative(const QPointF &pos, qreal scaleFactor, const QPointF &origin)
+inline QPointF scale(const QPointF &pos, qreal scaleFactor, QPointF origin = QPointF(0, 0))
 {
      return (pos - origin) * scaleFactor + origin;
 }
 
-inline QPoint fromNative(const QPoint &pos, qreal scaleFactor, const QPoint &origin)
-{
-     return (pos - origin) / scaleFactor + origin;
-}
-
-inline QPoint toNative(const QPoint &pos, qreal scaleFactor, const QPoint &origin)
+inline QPoint scale(const QPoint &pos, qreal scaleFactor, QPoint origin = QPoint(0, 0))
 {
      return (pos - origin) * scaleFactor + origin;
 }
 
-inline QPoint fromNative(const QPoint &pos, qreal scaleFactor)
-{
-     return pos / scaleFactor;
-}
-
-inline QPoint toNative(const QPoint &pos, qreal scaleFactor)
-{
-    return pos * scaleFactor;
-}
-
-inline QSize fromNative(const QSize &size, qreal scaleFactor)
-{
-    return size / scaleFactor; // TODO: should we round up?
-}
-
-inline QSize toNative(const QSize &size, qreal scaleFactor)
+inline QRect scale(const QRect &rect, qreal scaleFactor, QPoint origin = QPoint(0, 0))
 {
-    return size * scaleFactor;
-}
-
-inline QSizeF fromNative(const QSizeF &size, qreal scaleFactor)
-{
-    return size / scaleFactor;
-}
-
-inline QSizeF toNative(const QSizeF &size, qreal scaleFactor)
-{
-    return size * scaleFactor;
-}
-
-inline QRect fromNative(const QRect &rect, qreal scaleFactor, const QPoint &origin)
-{
-    return QRect(fromNative(rect.topLeft(), scaleFactor, origin), fromNative(rect.size(), scaleFactor));
-}
-
-inline QRect toNative(const QRect &rect, qreal scaleFactor, const QPoint &origin)
-{
-    return QRect(toNative(rect.topLeft(), scaleFactor, origin), toNative(rect.size(), scaleFactor));
-
-}
-
-inline QRect fromNative(const QRect &rect, const QScreen *screen, const QPoint &screenOrigin)
-{
-    return fromNative(rect, QHighDpiScaling::factor(screen), screenOrigin);
-}
-
-inline QRect fromNativeScreenGeometry(const QRect &nativeScreenGeometry, const QScreen *screen)
-{
-    return QRect(nativeScreenGeometry.topLeft(),
-                 fromNative(nativeScreenGeometry.size(), QHighDpiScaling::factor(screen)));
-}
-
-inline QPoint fromNativeLocalPosition(const QPoint &pos, const QWindow *window)
-{
-    const qreal scaleFactor = QHighDpiScaling::factor(window);
-    return pos / scaleFactor;
-}
-
-inline QPoint toNativeLocalPosition(const QPoint &pos, const QWindow *window)
-{
-    const qreal scaleFactor = QHighDpiScaling::factor(window);
-    return pos * scaleFactor;
-}
-
-inline QPointF fromNativeLocalPosition(const QPointF &pos, const QWindow *window)
-{
-    const qreal scaleFactor = QHighDpiScaling::factor(window);
-    return pos / scaleFactor;
-}
-
-inline QPointF toNativeLocalPosition(const QPointF &pos, const QWindow *window)
-{
-    const qreal scaleFactor = QHighDpiScaling::factor(window);
-    return pos * scaleFactor;
+    return QRect(scale(rect.topLeft(), scaleFactor, origin), scale(rect.size(), scaleFactor));
 }
 
-template <typename C>
-inline QRect fromNativePixels(const QRect &pixelRect, const C *context)
+inline QRectF scale(const QRectF &rect, qreal scaleFactor, QPoint origin = QPoint(0, 0))
 {
-    const qreal scaleFactor = QHighDpiScaling::factor(context);
-    const QPoint origin = QHighDpiScaling::origin(context);
-    return QRect(fromNative(pixelRect.topLeft(), scaleFactor, origin),
-                 fromNative(pixelRect.size(), scaleFactor));
+    return QRectF(scale(rect.topLeft(), scaleFactor, origin), scale(rect.size(), scaleFactor));
 }
 
-template <typename C>
-inline QRect toNativePixels(const QRect &pointRect, const C *context)
+inline QMargins scale(const QMargins &margins, qreal scaleFactor, QPoint origin = QPoint(0, 0))
 {
-    const qreal scaleFactor = QHighDpiScaling::factor(context);
-    const QPoint origin = QHighDpiScaling::origin(context);
-    return QRect(toNative(pointRect.topLeft(), scaleFactor, origin),
-                 toNative(pointRect.size(), scaleFactor));
+    Q_UNUSED(origin)
+    return QMargins(qRound(qreal(margins.left()) * scaleFactor), qRound(qreal(margins.top()) * scaleFactor),
+                    qRound(qreal(margins.right()) * scaleFactor), qRound(qreal(margins.bottom()) * scaleFactor));
 }
 
-template <typename C>
-inline QRectF toNativePixels(const QRectF &pointRect, const C *context)
+template <typename T>
+QVector<T> scale(const QVector<T> &vector, qreal scaleFactor, QPoint origin = QPoint(0, 0))
 {
-    const qreal scaleFactor = QHighDpiScaling::factor(context);
-    const QPoint origin = QHighDpiScaling::origin(context);
-    return QRectF(toNative(pointRect.topLeft(), scaleFactor, origin),
-                  toNative(pointRect.size(), scaleFactor));
-}
+    if (!QHighDpiScaling::isActive())
+        return vector;
 
-template <typename C>
-inline QRectF fromNativePixels(const QRectF &pixelRect, const C *context)
-{
-    const qreal scaleFactor = QHighDpiScaling::factor(context);
-    const QPoint origin = QHighDpiScaling::origin(context);
-    return QRectF(fromNative(pixelRect.topLeft(), scaleFactor, origin),
-                 fromNative(pixelRect.size(), scaleFactor));
+    QVector<T> scaled;
+    scaled.reserve(vector.size());
+    for (const T &item : vector)
+        scaled.append(scale(item, scaleFactor, origin));
+    return scaled;
 }
 
-inline QSize fromNativePixels(const QSize &pixelSize, const QWindow *window)
+inline QRegion scale(const QRegion &region, qreal scaleFactor, QPoint origin = QPoint(0, 0))
 {
-    return pixelSize / QHighDpiScaling::factor(window);
-}
+    if (!QHighDpiScaling::isActive())
+        return region;
 
-inline QSize toNativePixels(const QSize &pointSize, const QWindow *window)
-{
-    return pointSize * QHighDpiScaling::factor(window);
+    QRegion scaled;
+    for (const QRect &rect : region)
+        scaled += scale(rect, scaleFactor, origin);
+    return scaled;
 }
 
-inline QSizeF fromNativePixels(const QSizeF &pixelSize, const QWindow *window)
+template <typename T, typename C>
+T fromNativePixels(const T &value, const C *context)
 {
-    return pixelSize / QHighDpiScaling::factor(window);
+    return scale(value, qreal(1) / QHighDpiScaling::factor(context), QHighDpiScaling::origin(context));
 }
 
-inline QSizeF toNativePixels(const QSizeF &pointSize, const QWindow *window)
+template <typename T, typename C>
+T toNativePixels(const T &value, const C *context)
 {
-    return pointSize * QHighDpiScaling::factor(window);
+    return scale(value, QHighDpiScaling::factor(context), QHighDpiScaling::origin(context));
 }
 
-template <typename C>
-inline QPoint fromNativePixels(const QPoint &pixelPoint, const C *context)
+template <typename T, typename C>
+T fromNativeLocalPosition(const T &value, const C *context)
 {
-    return fromNative(pixelPoint, QHighDpiScaling::factor(context), QHighDpiScaling::origin(context));
+    return scale(value, qreal(1) / QHighDpiScaling::factor(context));
 }
 
-template <typename C>
-inline QPoint toNativePixels(const QPoint &pointPoint, const C *context)
+template <typename T, typename C>
+T toNativeLocalPosition(const T &value, const C *context)
 {
-    return toNative(pointPoint, QHighDpiScaling::factor(context), QHighDpiScaling::origin(context));
+    return scale(value, QHighDpiScaling::factor(context));
 }
 
-template <typename C>
-inline QPointF fromNativePixels(const QPointF &pixelPoint, const C *context)
+template <typename T>
+inline T fromNative(const T &value, qreal scaleFactor, QPoint origin = QPoint(0, 0))
 {
-    return fromNative(pixelPoint, QHighDpiScaling::factor(context), QHighDpiScaling::origin(context));
+    return scale(value, qreal(1) / scaleFactor, origin);
 }
 
-template <typename C>
-inline QPointF toNativePixels(const QPointF &pointPoint, const C *context)
+template <typename T>
+inline T toNative(const T &value, qreal scaleFactor, QPoint origin = QPoint(0, 0))
 {
-    return toNative(pointPoint, QHighDpiScaling::factor(context), QHighDpiScaling::origin(context));
+    return scale(value, scaleFactor, origin);
 }
 
-inline QMargins fromNativePixels(const QMargins &pixelMargins, const QWindow *window)
+inline QRect fromNative(const QRect &rect, const QScreen *screen, const QPoint &screenOrigin)
 {
-    const qreal scaleFactor = QHighDpiScaling::factor(window);
-    return QMargins(pixelMargins.left() / scaleFactor, pixelMargins.top() / scaleFactor,
-                    pixelMargins.right() / scaleFactor, pixelMargins.bottom() / scaleFactor);
+    return scale(rect, qreal(1) / QHighDpiScaling::factor(screen), screenOrigin);
 }
 
-inline QMargins toNativePixels(const QMargins &pointMargins, const QWindow *window)
+inline QRect fromNativeScreenGeometry(const QRect &nativeScreenGeometry, const QScreen *screen)
 {
-    const qreal scaleFactor = QHighDpiScaling::factor(window);
-    return QMargins(pointMargins.left() * scaleFactor, pointMargins.top() * scaleFactor,
-                    pointMargins.right() * scaleFactor, pointMargins.bottom() * scaleFactor);
+    return QRect(nativeScreenGeometry.topLeft(),
+                 scale(nativeScreenGeometry.size(), qreal(1) / QHighDpiScaling::factor(screen)));
 }
 
 inline QRegion fromNativeLocalRegion(const QRegion &pixelRegion, const QWindow *window)
 {
-    if (!QHighDpiScaling::isActive())
-        return pixelRegion;
-
-    qreal scaleFactor = QHighDpiScaling::factor(window);
-    QRegion pointRegion;
-    for (const QRect &rect : pixelRegion) {
-        pointRegion += QRect(fromNative(rect.topLeft(), scaleFactor),
-                             fromNative(rect.size(), scaleFactor));
-    }
-    return pointRegion;
+    return scale(pixelRegion, qreal(1) / QHighDpiScaling::factor(window));
 }
 
 // When mapping expose events to Qt rects: round top/left towards the origin and
@@ -333,67 +239,7 @@ inline QRegion fromNativeLocalExposedRegion(const QRegion &pixelRegion, const QW
 
 inline QRegion toNativeLocalRegion(const QRegion &pointRegion, const QWindow *window)
 {
-    if (!QHighDpiScaling::isActive())
-        return pointRegion;
-
-    qreal scaleFactor = QHighDpiScaling::factor(window);
-    QRegion pixelRegon;
-    for (const QRect &rect : pointRegion) {
-        pixelRegon += QRect(toNative(rect.topLeft(), scaleFactor),
-                             toNative(rect.size(), scaleFactor));
-    }
-    return pixelRegon;
-}
-
-// Any T that has operator/()
-template <typename T, typename C>
-T fromNativePixels(const T &pixelValue, const C *context)
-{
-    if (!QHighDpiScaling::isActive())
-        return pixelValue;
-
-    return pixelValue / QHighDpiScaling::factor(context);
-
-}
-
-// Any T that has operator*()
-template <typename T, typename C>
-T toNativePixels(const T &pointValue, const C *context)
-{
-    if (!QHighDpiScaling::isActive())
-        return pointValue;
-
-    return pointValue * QHighDpiScaling::factor(context);
-}
-
-// Any QVector<T> where T has operator/()
-template <typename T>
-QVector<T> fromNativePixels(const QVector<T> &pixelValues, const QWindow *window)
-{
-    if (!QHighDpiScaling::isActive())
-        return pixelValues;
-
-    QVector<T> pointValues;
-    pointValues.reserve(pixelValues.size());
-    const auto factor = QHighDpiScaling::factor(window);
-    for (const T &pixelValue : pixelValues)
-        pointValues.append(pixelValue / factor);
-    return pointValues;
-}
-
-// Any QVector<T> where T has operator*()
-template <typename T>
-QVector<T> toNativePixels(const QVector<T> &pointValues, const QWindow *window)
-{
-    if (!QHighDpiScaling::isActive())
-        return pointValues;
-
-    QVector<T> pixelValues;
-    pixelValues.reserve(pointValues.size());
-    const auto factor = QHighDpiScaling::factor(window);
-    for (const T &pointValue : pointValues)
-        pixelValues.append(pointValue * factor);
-    return pixelValues;
+    return scale(pointRegion, QHighDpiScaling::factor(window));
 }
 
 } // namespace QHighDpi
diff --git a/src/gui/math3d/qvector3d.cpp b/src/gui/math3d/qvector3d.cpp
index 12a7902272..4f72c1da66 100644
--- a/src/gui/math3d/qvector3d.cpp
+++ b/src/gui/math3d/qvector3d.cpp
@@ -514,7 +514,7 @@ float QVector3D::distanceToPlane
 /*!
     \overload
 
-    Returns the distance from this vertex a plane defined by
+    Returns the distance from this vertex to a plane defined by
     the vertices \a plane1, \a plane2 and \a plane3.
 
     The return value will be negative if the vertex is below the plane,
diff --git a/src/gui/opengl/qopengltextureblitter.cpp b/src/gui/opengl/qopengltextureblitter.cpp
index b65df9dc82..b709f2f639 100644
--- a/src/gui/opengl/qopengltextureblitter.cpp
+++ b/src/gui/opengl/qopengltextureblitter.cpp
@@ -349,6 +349,9 @@ bool QOpenGLTextureBlitterPrivate::buildProgram(ProgramIndex idx, const char *vs
 
     p->glProgram->setUniformValue(p->swizzleUniformPos, false);
 
+    // minmize state left set after a create()
+    p->glProgram->release();
+
     return true;
 }
 
diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp
index ac15d8f4f4..006befea22 100644
--- a/src/gui/painting/qdrawhelper.cpp
+++ b/src/gui/painting/qdrawhelper.cpp
@@ -4566,7 +4566,9 @@ static void blend_color_rgb16(int count, const QSpan *spans, void *userData)
     if (mode == QPainter::CompositionMode_Source) {
         // inline for performance
         ushort c = data->solidColor.toRgb16();
-        while (count--) {
+        for (; count--; spans++) {
+            if (!spans->len)
+                continue;
             ushort *target = ((ushort *)data->rasterBuffer->scanLine(spans->y)) + spans->x;
             if (spans->coverage == 255) {
                 qt_memfill(target, c, spans->len);
@@ -4579,13 +4581,14 @@ static void blend_color_rgb16(int count, const QSpan *spans, void *userData)
                     ++target;
                 }
             }
-            ++spans;
         }
         return;
     }
 
     if (mode == QPainter::CompositionMode_SourceOver) {
-        while (count--) {
+        for (; count--; spans++) {
+            if (!spans->len)
+                continue;
             uint color = BYTE_MUL(data->solidColor.toArgb32(), spans->coverage);
             int ialpha = qAlpha(~color);
             ushort c = qConvertRgb32To16(color);
@@ -4617,7 +4620,6 @@ static void blend_color_rgb16(int count, const QSpan *spans, void *userData)
                 // one last pixel beyond a full word
                 *target = c + BYTE_MUL_RGB16(*target, ialpha);
             }
-            ++spans;
         }
         return;
     }
@@ -4634,6 +4636,11 @@ void handleSpans(int count, const QSpan *spans, const QSpanData *data, T &handle
 
     int coverage = 0;
     while (count) {
+        if (!spans->len) {
+            ++spans;
+            --count;
+            continue;
+        }
         int x = spans->x;
         const int y = spans->y;
         int right = x + spans->len;
@@ -4790,7 +4797,9 @@ static void blend_untransformed_generic(int count, const QSpan *spans, void *use
     int xoff = -qRound(-data->dx);
     int yoff = -qRound(-data->dy);
 
-    while (count--) {
+    for (; count--; spans++) {
+        if (!spans->len)
+            continue;
         int x = spans->x;
         int length = spans->len;
         int sx = xoff + x;
@@ -4818,7 +4827,6 @@ static void blend_untransformed_generic(int count, const QSpan *spans, void *use
                 }
             }
         }
-        ++spans;
     }
 }
 
@@ -4840,7 +4848,9 @@ static void blend_untransformed_generic_rgb64(int count, const QSpan *spans, voi
     int xoff = -qRound(-data->dx);
     int yoff = -qRound(-data->dy);
 
-    while (count--) {
+    for (; count--; spans++) {
+        if (!spans->len)
+            continue;
         int x = spans->x;
         int length = spans->len;
         int sx = xoff + x;
@@ -4868,7 +4878,6 @@ static void blend_untransformed_generic_rgb64(int count, const QSpan *spans, voi
                 }
             }
         }
-        ++spans;
     }
 }
 #endif
@@ -4889,7 +4898,9 @@ static void blend_untransformed_argb(int count, const QSpan *spans, void *userDa
     int xoff = -qRound(-data->dx);
     int yoff = -qRound(-data->dy);
 
-    while (count--) {
+    for (; count--; spans++) {
+        if (!spans->len)
+            continue;
         int x = spans->x;
         int length = spans->len;
         int sx = xoff + x;
@@ -4909,7 +4920,6 @@ static void blend_untransformed_argb(int count, const QSpan *spans, void *userDa
                 op.func(dest, src, length, coverage);
             }
         }
-        ++spans;
     }
 }
 
@@ -4982,7 +4992,12 @@ static void blend_untransformed_rgb565(int count, const QSpan *spans, void *user
     int xoff = -qRound(-data->dx);
     int yoff = -qRound(-data->dy);
 
-    while (count--) {
+    const QSpan *end = spans + count;
+    while (spans < end) {
+        if (!spans->len) {
+            ++spans;
+            continue;
+        }
         const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
         if (coverage == 0) {
             ++spans;
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index 85ddff53db..64183c2be6 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -4149,7 +4149,7 @@ static void qt_span_fill_clipped(int spanCount, const QSpan *spans, void *userDa
     Clip spans to \a{clip}-rectangle.
     Returns number of unclipped spans
 */
-static int qt_intersect_spans(QT_FT_Span *spans, int numSpans,
+static int qt_intersect_spans(QT_FT_Span *&spans, int numSpans,
                               const QRect &clip)
 {
     const short minx = clip.left();
@@ -4157,29 +4157,32 @@ static int qt_intersect_spans(QT_FT_Span *spans, int numSpans,
     const short maxx = clip.right();
     const short maxy = clip.bottom();
 
-    int n = 0;
-    for (int i = 0; i < numSpans; ++i) {
-        if (spans[i].y > maxy)
+    QT_FT_Span *end = spans + numSpans;
+    while (spans < end) {
+        if (spans->y >= miny)
             break;
-        if (spans[i].y < miny
-            || spans[i].x > maxx
-            || spans[i].x + spans[i].len <= minx) {
+        ++spans;
+    }
+
+    QT_FT_Span *s = spans;
+    while (s < end) {
+        if (s->y > maxy)
+            break;
+        if (s->x > maxx || s->x + s->len <= minx) {
+            s->len = 0;
+            ++s;
             continue;
         }
-        if (spans[i].x < minx) {
-            spans[n].len = qMin(spans[i].len - (minx - spans[i].x), maxx - minx + 1);
-            spans[n].x = minx;
+        if (s->x < minx) {
+            s->len = qMin(s->len - (minx - s->x), maxx - minx + 1);
+            s->x = minx;
         } else {
-            spans[n].x = spans[i].x;
-            spans[n].len = qMin(spans[i].len, ushort(maxx - spans[n].x + 1));
+            s->len = qMin(s->len, ushort(maxx - s->x + 1));
         }
-        if (spans[n].len == 0)
-            continue;
-        spans[n].y = spans[i].y;
-        spans[n].coverage = spans[i].coverage;
-        ++n;
+        ++s;
     }
-    return n;
+
+    return s - spans;
 }
 
 
@@ -4192,11 +4195,12 @@ static void qt_span_fill_clipRect(int count, const QSpan *spans,
     Q_ASSERT(fillData->clip);
     Q_ASSERT(!fillData->clip->clipRect.isEmpty());
 
+    QSpan *s = const_cast<QSpan *>(spans);
     // hw: check if this const_cast<> is safe!!!
-    count = qt_intersect_spans(const_cast<QSpan*>(spans), count,
+    count = qt_intersect_spans(s, count,
                                fillData->clip->clipRect);
     if (count > 0)
-        fillData->unclipped_blend(count, spans, fillData);
+        fillData->unclipped_blend(count, s, fillData);
 }
 
 static void qt_span_clip(int count, const QSpan *spans, void *userData)
@@ -4773,7 +4777,8 @@ static inline void drawEllipsePoints(int x, int y, int length,
     if (length == 0)
         return;
 
-    QT_FT_Span outline[4];
+    QT_FT_Span _outline[4];
+    QT_FT_Span *outline = _outline;
     const int midx = rect.x() + (rect.width() + 1) / 2;
     const int midy = rect.y() + (rect.height() + 1) / 2;
 
@@ -4805,7 +4810,8 @@ static inline void drawEllipsePoints(int x, int y, int length,
     outline[3].coverage = 255;
 
     if (brush_func && outline[0].x + outline[0].len < outline[1].x) {
-        QT_FT_Span fill[2];
+        QT_FT_Span _fill[2];
+        QT_FT_Span *fill = _fill;
 
         // top fill
         fill[0].x = outline[0].x + outline[0].len - 1;
diff --git a/src/gui/painting/qstroker.cpp b/src/gui/painting/qstroker.cpp
index 5b6990e667..271d3ba6bf 100644
--- a/src/gui/painting/qstroker.cpp
+++ b/src/gui/painting/qstroker.cpp
@@ -522,7 +522,7 @@ void QStroker::joinPoints(qfixed focal_x, qfixed focal_y, const QLineF &nextLine
 
             QLineF shortCut(prevLine.p2(), nextLine.p1());
             qreal angle = shortCut.angleTo(prevLine);
-            if (type == QLineF::BoundedIntersection || (angle > 90 && !qFuzzyCompare(angle, (qreal)90))) {
+            if ((type == QLineF::BoundedIntersection || (angle > qreal(90.01))) && nextLine.length() > offset) {
                 emitLineTo(focal_x, focal_y);
                 emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1()));
                 return;
diff --git a/src/gui/text/qdistancefield.cpp b/src/gui/text/qdistancefield.cpp
index 3f7129383b..17824a5ba1 100644
--- a/src/gui/text/qdistancefield.cpp
+++ b/src/gui/text/qdistancefield.cpp
@@ -899,11 +899,6 @@ QDistanceField::QDistanceField(int width, int height)
 {
 }
 
-QDistanceField::QDistanceField(const QDistanceField &other)
-{
-    d = other.d;
-}
-
 QDistanceField &QDistanceField::operator=(const QDistanceField &)
     = default;
 
diff --git a/src/gui/text/qdistancefield_p.h b/src/gui/text/qdistancefield_p.h
index dc5d5a9a02..d6d8edd85d 100644
--- a/src/gui/text/qdistancefield_p.h
+++ b/src/gui/text/qdistancefield_p.h
@@ -94,7 +94,6 @@ public:
     QDistanceField(const QRawFont &font, glyph_t glyph, bool doubleResolution = false);
     QDistanceField(QFontEngine *fontEngine, glyph_t glyph, bool doubleResolution = false);
     QDistanceField(const QPainterPath &path, glyph_t glyph, bool doubleResolution = false);
-    QDistanceField(const QDistanceField &other);
     QDistanceField &operator=(const QDistanceField &other);
 
     bool isNull() const;