Merge remote-tracking branch 'origin/tqtc/lts-5.15.8' into tqtc/lts-5.15-opensourcev5.15.8-lts-lgpl

Change-Id: I569a2246c9e8d70430e8c5405b9f3df2218078ee

13 files changed, 244 insertions, 109 deletions

diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp
index 64efc17fe5..7152ac1607 100644
--- a/src/gui/image/qimage.cpp
+++ b/src/gui/image/qimage.cpp
@@ -2258,6 +2258,7 @@ bool QImage::reinterpretAsFormat(Format format)
         // In case detach() ran out of memory
         if (!d) {
             d = oldD;
+            d->ref.ref();
             return false;
         }
     }
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
index 9ea1e18c45..a9cc404256 100644
--- a/src/gui/image/qpixmap.cpp
+++ b/src/gui/image/qpixmap.cpp
@@ -926,6 +926,7 @@ void QPixmap::fill(const QColor &color)
         // it will be filled with new pixel data anyway.
         QPlatformPixmap *d = data->createCompatiblePlatformPixmap();
         d->resize(data->width(), data->height());
+        d->setDevicePixelRatio(data->devicePixelRatio());
         data = d;
     }
     data->fill(color);
diff --git a/src/gui/image/qppmhandler.cpp b/src/gui/image/qppmhandler.cpp
index 728259ba9e..b03458bdd9 100644
--- a/src/gui/image/qppmhandler.cpp
+++ b/src/gui/image/qppmhandler.cpp
@@ -63,7 +63,7 @@ static void discard_pbm_line(QIODevice *d)
     } while (res > 0 && buf[res-1] != '\n');
 }
 
-static int read_pbm_int(QIODevice *d)
+static int read_pbm_int(QIODevice *d, bool *ok)
 {
     char c;
     int          val = -1;
@@ -97,6 +97,8 @@ static int read_pbm_int(QIODevice *d)
         else
             break;
     }
+    if (val < 0)
+        *ok = false;
     return hasOverflow ? -1 : val;
 }
 
@@ -113,16 +115,17 @@ static bool read_pbm_header(QIODevice *device, char& type, int& w, int& h, int&
     if (type < '1' || type > '6')
         return false;
 
-    w = read_pbm_int(device);                        // get image width
-    h = read_pbm_int(device);                        // get image height
+    bool ok = true;
+    w = read_pbm_int(device, &ok);                // get image width
+    h = read_pbm_int(device, &ok);                // get image height
 
     if (type == '1' || type == '4')
         mcc = 1;                                  // ignore max color component
     else
-        mcc = read_pbm_int(device);               // get max color component
+        mcc = read_pbm_int(device, &ok);          // get max color component
 
-    if (w <= 0 || w > 32767 || h <= 0 || h > 32767 || mcc <= 0 || mcc > 0xffff)
-        return false;                                        // weird P.M image
+    if (!ok || w <= 0 || w > 32767 || h <= 0 || h > 32767 || mcc <= 0 || mcc > 0xffff)
+        return false;                             // weird P.M image
 
     return true;
 }
@@ -233,18 +236,18 @@ static bool read_pbm_body(QIODevice *device, char type, int w, int h, int mcc, Q
     } else {                                        // read ascii data
         uchar *p;
         int n;
-        char buf;
-        for (y = 0; (y < h) && (device->peek(&buf, 1) == 1); y++) {
+        bool ok = true;
+        for (y = 0; y < h && ok; y++) {
             p = outImage->scanLine(y);
             n = pbm_bpl;
             if (nbits == 1) {
                 int b;
                 int bitsLeft = w;
-                while (n--) {
+                while (n-- && ok) {
                     b = 0;
                     for (int i=0; i<8; i++) {
                         if (i < bitsLeft)
-                            b = (b << 1) | (read_pbm_int(device) & 1);
+                            b = (b << 1) | (read_pbm_int(device, &ok) & 1);
                         else
                             b = (b << 1) | (0 & 1); // pad it our self if we need to
                     }
@@ -253,36 +256,38 @@ static bool read_pbm_body(QIODevice *device, char type, int w, int h, int mcc, Q
                 }
             } else if (nbits == 8) {
                 if (mcc == 255) {
-                    while (n--) {
-                        *p++ = read_pbm_int(device);
+                    while (n-- && ok) {
+                        *p++ = read_pbm_int(device, &ok);
                     }
                 } else {
-                    while (n--) {
-                        *p++ = (read_pbm_int(device) & 0xffff) * 255 / mcc;
+                    while (n-- && ok) {
+                        *p++ = (read_pbm_int(device, &ok) & 0xffff) * 255 / mcc;
                     }
                 }
             } else {                                // 32 bits
                 n /= 4;
                 int r, g, b;
                 if (mcc == 255) {
-                    while (n--) {
-                        r = read_pbm_int(device);
-                        g = read_pbm_int(device);
-                        b = read_pbm_int(device);
+                    while (n-- && ok) {
+                        r = read_pbm_int(device, &ok);
+                        g = read_pbm_int(device, &ok);
+                        b = read_pbm_int(device, &ok);
                         *((QRgb*)p) = qRgb(r, g, b);
                         p += 4;
                     }
                 } else {
-                    while (n--) {
-                        r = read_pbm_int(device);
-                        g = read_pbm_int(device);
-                        b = read_pbm_int(device);
+                    while (n-- && ok) {
+                        r = read_pbm_int(device, &ok);
+                        g = read_pbm_int(device, &ok);
+                        b = read_pbm_int(device, &ok);
                         *((QRgb*)p) = scale_pbm_color(mcc, r, g, b);
                         p += 4;
                     }
                 }
             }
         }
+        if (!ok)
+            return false;
     }
 
     if (format == QImage::Format_Mono) {
diff --git a/src/gui/kernel/qwindow.cpp b/src/gui/kernel/qwindow.cpp
index 4cc4e1ad04..c1c79a74ce 100644
--- a/src/gui/kernel/qwindow.cpp
+++ b/src/gui/kernel/qwindow.cpp
@@ -1935,7 +1935,12 @@ void QWindow::resize(const QSize &newSize)
     Q_D(QWindow);
     d->positionPolicy = QWindowPrivate::WindowFrameExclusive;
     if (d->platformWindow) {
-        d->platformWindow->setGeometry(QHighDpi::toNativePixels(QRect(position(), newSize), this));
+        if (isTopLevel()) {
+            d->platformWindow->setGeometry(QHighDpi::toNativePixels(QRect(position(), newSize), this));
+        } else {
+            d->platformWindow->setGeometry(QRect(QHighDpi::toNativeLocalPosition(position(), this),
+                                                 QHighDpi::toNativePixels(newSize, this)));
+        }
     } else {
         const QSize oldSize = d->geometry.size();
         d->geometry.setSize(newSize);
diff --git a/src/gui/opengl/qopenglprogrambinarycache.cpp b/src/gui/opengl/qopenglprogrambinarycache.cpp
index 72bdacf43f..dd1462018f 100644
--- a/src/gui/opengl/qopenglprogrambinarycache.cpp
+++ b/src/gui/opengl/qopenglprogrambinarycache.cpp
@@ -120,20 +120,24 @@ QOpenGLProgramBinaryCache::QOpenGLProgramBinaryCache()
 {
     const QString subPath = QLatin1String("/qtshadercache-") + QSysInfo::buildAbi() + QLatin1Char('/');
     const QString sharedCachePath = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation);
+    m_globalCacheDir = sharedCachePath + subPath;
+    m_localCacheDir = QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + subPath;
+
     if (!sharedCachePath.isEmpty()) {
-        m_cacheDir = sharedCachePath + subPath;
-        m_cacheWritable = qt_ensureWritableDir(m_cacheDir);
+        m_currentCacheDir = m_globalCacheDir;
+        m_cacheWritable = qt_ensureWritableDir(m_currentCacheDir);
     }
     if (!m_cacheWritable) {
-        m_cacheDir = QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + subPath;
-        m_cacheWritable = qt_ensureWritableDir(m_cacheDir);
+        m_currentCacheDir = m_localCacheDir;
+        m_cacheWritable = qt_ensureWritableDir(m_currentCacheDir);
     }
-    qCDebug(lcOpenGLProgramDiskCache, "Cache location '%s' writable = %d", qPrintable(m_cacheDir), m_cacheWritable);
+
+    qCDebug(lcOpenGLProgramDiskCache, "Cache location '%s' writable = %d", qPrintable(m_currentCacheDir), m_cacheWritable);
 }
 
 QString QOpenGLProgramBinaryCache::cacheFileName(const QByteArray &cacheKey) const
 {
-    return m_cacheDir + QString::fromUtf8(cacheKey);
+    return m_currentCacheDir + QString::fromUtf8(cacheKey);
 }
 
 #define BASE_HEADER_SIZE (int(4 * sizeof(quint32)))
@@ -362,6 +366,25 @@ static inline void writeStr(uchar **p, const QByteArray &str)
     *p += str.size();
 }
 
+static inline bool writeFile(const QString &filename, const QByteArray &data)
+{
+#if QT_CONFIG(temporaryfile)
+    QSaveFile f(filename);
+    if (f.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
+        f.write(data);
+        if (f.commit())
+            return true;
+    }
+#else
+    QFile f(filename);
+    if (f.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
+        if (f.write(data) == data.length())
+            return true;
+    }
+#endif
+    return false;
+}
+
 void QOpenGLProgramBinaryCache::save(const QByteArray &cacheKey, uint programId)
 {
     if (!m_cacheWritable)
@@ -428,20 +451,20 @@ void QOpenGLProgramBinaryCache::save(const QByteArray &cacheKey, uint programId)
 
     writeUInt(&blobFormatPtr, blobFormat);
 
-#if QT_CONFIG(temporaryfile)
-    QSaveFile f(cacheFileName(cacheKey));
-    if (f.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
-        f.write(blob);
-        if (!f.commit())
-#else
-    QFile f(cacheFileName(cacheKey));
-    if (f.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
-        if (f.write(blob) < blob.length())
-#endif
-            qCDebug(lcOpenGLProgramDiskCache, "Failed to write %s to shader cache", qPrintable(f.fileName()));
-    } else {
-        qCDebug(lcOpenGLProgramDiskCache, "Failed to create %s in shader cache", qPrintable(f.fileName()));
+    QString filename = cacheFileName(cacheKey);
+    bool ok = writeFile(filename, blob);
+    if (!ok && m_currentCacheDir == m_globalCacheDir) {
+        m_currentCacheDir = m_localCacheDir;
+        m_cacheWritable = qt_ensureWritableDir(m_currentCacheDir);
+        qCDebug(lcOpenGLProgramDiskCache, "Cache location changed to '%s' writable = %d",
+                qPrintable(m_currentCacheDir), m_cacheWritable);
+        if (m_cacheWritable) {
+            filename = cacheFileName(cacheKey);
+            ok = writeFile(filename, blob);
+        }
     }
+    if (!ok)
+        qCDebug(lcOpenGLProgramDiskCache, "Failed to write %s to shader cache", qPrintable(filename));
 }
 
 #if defined(QT_OPENGL_ES_2)
diff --git a/src/gui/opengl/qopenglprogrambinarycache_p.h b/src/gui/opengl/qopenglprogrambinarycache_p.h
index f1cf24cd87..55685f362e 100644
--- a/src/gui/opengl/qopenglprogrambinarycache_p.h
+++ b/src/gui/opengl/qopenglprogrambinarycache_p.h
@@ -89,7 +89,9 @@ private:
     bool verifyHeader(const QByteArray &buf) const;
     bool setProgramBinary(uint programId, uint blobFormat, const void *p, uint blobSize);
 
-    QString m_cacheDir;
+    QString m_globalCacheDir;
+    QString m_localCacheDir;
+    QString m_currentCacheDir;
     bool m_cacheWritable;
     struct MemCacheEntry {
         MemCacheEntry(const void *p, int size, uint format)
diff --git a/src/gui/opengl/qopengltextureblitter.cpp b/src/gui/opengl/qopengltextureblitter.cpp
index b709f2f639..9ec9d67d96 100644
--- a/src/gui/opengl/qopengltextureblitter.cpp
+++ b/src/gui/opengl/qopengltextureblitter.cpp
@@ -44,10 +44,20 @@
 #include <QtGui/QOpenGLVertexArrayObject>
 #include <QtGui/QOpenGLContext>
 #include <QtGui/QOpenGLFunctions>
+#include <QtGui/QOpenGLExtraFunctions>
 
 #ifndef GL_TEXTURE_EXTERNAL_OES
 #define GL_TEXTURE_EXTERNAL_OES           0x8D65
 #endif
+#ifndef GL_TEXTURE_RECTANGLE
+#define GL_TEXTURE_RECTANGLE              0x84F5
+#endif
+#ifndef GL_TEXTURE_WIDTH
+#define GL_TEXTURE_WIDTH                  0x1000
+#endif
+#ifndef GL_TEXTURE_HEIGHT
+#define GL_TEXTURE_HEIGHT                 0x1001
+#endif
 
 QT_BEGIN_NAMESPACE
 
@@ -153,6 +163,30 @@ static const char fragment_shader_external_oes[] =
     "   gl_FragColor = swizzle ? tmpFragColor.bgra : tmpFragColor;"
     "}";
 
+static const char fragment_shader_rectangle[] =
+    "varying highp vec2 uv;"
+    "uniform sampler2DRect textureSampler;"
+    "uniform bool swizzle;"
+    "uniform highp float opacity;"
+    "void main() {"
+    "   highp vec4 tmpFragColor = texture2DRect(textureSampler,uv);"
+    "   tmpFragColor.a *= opacity;"
+    "   gl_FragColor = swizzle ? tmpFragColor.bgra : tmpFragColor;"
+    "}";
+
+static const char fragment_shader150_rectangle[] =
+    "#version 150 core\n"
+    "in vec2 uv;"
+    "out vec4 fragcolor;"
+    "uniform sampler2DRect textureSampler;"
+    "uniform bool swizzle;"
+    "uniform float opacity;"
+    "void main() {"
+    "   vec4 tmpFragColor = texture(textureSampler, uv);"
+    "   tmpFragColor.a *= opacity;"
+    "   fragcolor = swizzle ? tmpFragColor.bgra : tmpFragColor;"
+    "}";
+
 static const GLfloat vertex_buffer_data[] = {
         -1,-1, 0,
         -1, 1, 0,
@@ -198,7 +232,8 @@ public:
 
     enum ProgramIndex {
         TEXTURE_2D,
-        TEXTURE_EXTERNAL_OES
+        TEXTURE_EXTERNAL_OES,
+        TEXTURE_RECTANGLE
     };
 
     QOpenGLTextureBlitterPrivate() :
@@ -210,11 +245,15 @@ public:
 
     bool buildProgram(ProgramIndex idx, const char *vs, const char *fs);
 
-    void blit(GLuint texture, const QMatrix4x4 &vertexTransform, const QMatrix3x3 &textureTransform);
-    void blit(GLuint texture, const QMatrix4x4 &vertexTransform, QOpenGLTextureBlitter::Origin origin);
+    void blit(GLuint texture, const QMatrix4x4 &targetTransform, const QMatrix3x3 &sourceTransform);
+    void blit(GLuint texture, const QMatrix4x4 &targetTransform, QOpenGLTextureBlitter::Origin origin);
+
+    QMatrix3x3 toTextureCoordinates(const QMatrix3x3 &sourceTransform) const;
 
     void prepareProgram(const QMatrix4x4 &vertexTransform);
 
+    bool supportsRectangleTarget() const;
+
     QOpenGLBuffer vertexBuffer;
     QOpenGLBuffer textureBuffer;
     struct Program {
@@ -239,7 +278,7 @@ public:
         bool swizzle;
         float opacity;
         TextureMatrixUniform textureMatrixUniformState;
-    } programs[2];
+    } programs[3];
     bool swizzle;
     float opacity;
     QScopedPointer<QOpenGLVertexArrayObject> vao;
@@ -253,6 +292,8 @@ static inline QOpenGLTextureBlitterPrivate::ProgramIndex targetToProgramIndex(GL
         return QOpenGLTextureBlitterPrivate::TEXTURE_2D;
     case GL_TEXTURE_EXTERNAL_OES:
         return QOpenGLTextureBlitterPrivate::TEXTURE_EXTERNAL_OES;
+    case GL_TEXTURE_RECTANGLE:
+        return QOpenGLTextureBlitterPrivate::TEXTURE_RECTANGLE;
     default:
         qWarning("Unsupported texture target 0x%x", target);
         return QOpenGLTextureBlitterPrivate::TEXTURE_2D;
@@ -286,14 +327,33 @@ void QOpenGLTextureBlitterPrivate::prepareProgram(const QMatrix4x4 &vertexTransf
     }
 }
 
+QMatrix3x3 QOpenGLTextureBlitterPrivate::toTextureCoordinates(const QMatrix3x3 &sourceTransform) const
+{
+    if (currentTarget == GL_TEXTURE_RECTANGLE) {
+        // Non-normalized coordinates
+        QMatrix4x4 textureTransform(sourceTransform);
+        if (auto *glFunctions = QOpenGLContext::currentContext()->extraFunctions()) {
+            int width, height;
+            glFunctions->glGetTexLevelParameteriv(currentTarget, 0, GL_TEXTURE_WIDTH, &width);
+            glFunctions->glGetTexLevelParameteriv(currentTarget, 0, GL_TEXTURE_HEIGHT, &height);
+            textureTransform.scale(width, height);
+        }
+        return textureTransform.toGenericMatrix<3, 3>();
+    }
+
+    return sourceTransform; // Normalized coordinates
+}
+
 void QOpenGLTextureBlitterPrivate::blit(GLuint texture,
-                                        const QMatrix4x4 &vertexTransform,
-                                        const QMatrix3x3 &textureTransform)
+                                        const QMatrix4x4 &targetTransform,
+                                        const QMatrix3x3 &sourceTransform)
 {
     TextureBinder binder(currentTarget, texture);
-    prepareProgram(vertexTransform);
+    prepareProgram(targetTransform);
 
     Program *program = &programs[targetToProgramIndex(currentTarget)];
+
+    const QMatrix3x3 textureTransform = toTextureCoordinates(sourceTransform);
     program->glProgram->setUniformValue(program->textureTransformUniformPos, textureTransform);
     program->textureMatrixUniformState = User;
 
@@ -301,23 +361,26 @@ void QOpenGLTextureBlitterPrivate::blit(GLuint texture,
 }
 
 void QOpenGLTextureBlitterPrivate::blit(GLuint texture,
-                                        const QMatrix4x4 &vertexTransform,
+                                        const QMatrix4x4 &targetTransform,
                                         QOpenGLTextureBlitter::Origin origin)
 {
     TextureBinder binder(currentTarget, texture);
-    prepareProgram(vertexTransform);
+    prepareProgram(targetTransform);
 
     Program *program = &programs[targetToProgramIndex(currentTarget)];
+
     if (origin == QOpenGLTextureBlitter::OriginTopLeft) {
         if (program->textureMatrixUniformState != IdentityFlipped) {
-            QMatrix3x3 flipped;
-            flipped(1,1) = -1;
-            flipped(1,2) = 1;
-            program->glProgram->setUniformValue(program->textureTransformUniformPos, flipped);
+            QMatrix3x3 sourceTransform;
+            sourceTransform(1,1) = -1;
+            sourceTransform(1,2) = 1;
+            const QMatrix3x3 textureTransform = toTextureCoordinates(sourceTransform);
+            program->glProgram->setUniformValue(program->textureTransformUniformPos, textureTransform);
             program->textureMatrixUniformState = IdentityFlipped;
         }
     } else if (program->textureMatrixUniformState != Identity) {
-        program->glProgram->setUniformValue(program->textureTransformUniformPos, QMatrix3x3());
+        const QMatrix3x3 textureTransform = toTextureCoordinates(QMatrix3x3());
+        program->glProgram->setUniformValue(program->textureTransformUniformPos, textureTransform);
         program->textureMatrixUniformState = Identity;
     }
 
@@ -408,12 +471,18 @@ bool QOpenGLTextureBlitter::create()
     if (format.profile() == QSurfaceFormat::CoreProfile && format.version() >= qMakePair(3,2)) {
         if (!d->buildProgram(QOpenGLTextureBlitterPrivate::TEXTURE_2D, vertex_shader150, fragment_shader150))
             return false;
+        if (d->supportsRectangleTarget())
+            if (!d->buildProgram(QOpenGLTextureBlitterPrivate::TEXTURE_RECTANGLE, vertex_shader150, fragment_shader150_rectangle))
+                return false;
     } else {
         if (!d->buildProgram(QOpenGLTextureBlitterPrivate::TEXTURE_2D, vertex_shader, fragment_shader))
             return false;
         if (supportsExternalOESTarget())
             if (!d->buildProgram(QOpenGLTextureBlitterPrivate::TEXTURE_EXTERNAL_OES, vertex_shader, fragment_shader_external_oes))
                 return false;
+        if (d->supportsRectangleTarget())
+            if (!d->buildProgram(QOpenGLTextureBlitterPrivate::TEXTURE_RECTANGLE, vertex_shader, fragment_shader_rectangle))
+                return false;
     }
 
     // Create and bind the VAO, if supported.
@@ -459,6 +528,7 @@ void QOpenGLTextureBlitter::destroy()
     Q_D(QOpenGLTextureBlitter);
     d->programs[QOpenGLTextureBlitterPrivate::TEXTURE_2D].glProgram.reset();
     d->programs[QOpenGLTextureBlitterPrivate::TEXTURE_EXTERNAL_OES].glProgram.reset();
+    d->programs[QOpenGLTextureBlitterPrivate::TEXTURE_RECTANGLE].glProgram.reset();
     d->vertexBuffer.destroy();
     d->textureBuffer.destroy();
     d->vao.reset();
@@ -477,13 +547,39 @@ bool QOpenGLTextureBlitter::supportsExternalOESTarget() const
 }
 
 /*!
+    \return \c true when bind() accepts \c GL_TEXTURE_RECTANGLE as
+    its target argument.
+
+    \sa bind(), blit()
+ */
+bool QOpenGLTextureBlitterPrivate::supportsRectangleTarget() const
+{
+    QOpenGLContext *ctx = QOpenGLContext::currentContext();
+    if (!ctx || ctx->isOpenGLES())
+        return false;
+
+    if (ctx->hasExtension("GL_ARB_texture_rectangle"))
+        return true;
+
+     if (ctx->hasExtension("GL_EXT_texture_rectangle"))
+         return true;
+
+    QSurfaceFormat f = ctx->format();
+    const auto version = qMakePair(f.majorVersion(), f.minorVersion());
+    if (version >= qMakePair(3, 1))
+        return true;
+
+    return false;
+}
+
+/*!
     Binds the graphics resources used by the blitter. This must be
     called before calling blit(). Code modifying the OpenGL state
     should be avoided between the call to bind() and blit() because
     otherwise conflicts may arise.
 
     \a target is the texture target for the source texture and must be
-    either \c GL_TEXTURE_2D or \c GL_OES_EGL_image_external.
+    either \c GL_TEXTURE_2D, \c GL_TEXTURE_RECTANGLE, or \c GL_OES_EGL_image_external.
 
     \sa release(), blit()
  */
@@ -586,7 +682,7 @@ void QOpenGLTextureBlitter::blit(GLuint texture,
                                  Origin sourceOrigin)
 {
     Q_D(QOpenGLTextureBlitter);
-    d->blit(texture,targetTransform, sourceOrigin);
+    d->blit(texture, targetTransform, sourceOrigin);
 }
 
 /*!
diff --git a/src/gui/painting/painting.pri b/src/gui/painting/painting.pri
index c68e8d6e9a..bb0fc0ffba 100644
--- a/src/gui/painting/painting.pri
+++ b/src/gui/painting/painting.pri
@@ -146,7 +146,7 @@ gcc:equals(QT_GCC_MAJOR_VERSION, 5) {
     NEON_HEADERS += painting/qdrawhelper_neon_p.h
 }
 !uikit:!win32:contains(QT_ARCH, "arm"): CONFIG += no_clang_integrated_as
-!android:!uikit:!win32:!integrity:!contains(QT_ARCH, "arm64") {
+!macos:!android:!uikit:!win32:!integrity:!contains(QT_ARCH, "arm64") {
     NEON_ASM += ../3rdparty/pixman/pixman-arm-neon-asm.S painting/qdrawhelper_neon_asm.S
     DEFINES += ENABLE_PIXMAN_DRAWHELPERS
 }
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index aaeb0e86a2..826a7ab27f 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -175,6 +175,23 @@ static bool qt_painter_thread_test(int devType, int engineType, const char *what
 }
 #endif
 
+static bool needsEmulation(const QBrush &brush)
+{
+    bool res = false;
+
+    const QGradient *bg = brush.gradient();
+    if (bg) {
+        res = (bg->coordinateMode() > QGradient::LogicalMode);
+    } else if (brush.style() == Qt::TexturePattern) {
+        if (qHasPixmapTexture(brush))
+            res = !qFuzzyCompare(brush.texture().devicePixelRatio(), qreal(1.0));
+        else
+            res = !qFuzzyCompare(brush.textureImage().devicePixelRatio(), qreal(1.0));
+    }
+
+    return res;
+}
+
 void QPainterPrivate::checkEmulation()
 {
     Q_ASSERT(extended);
@@ -182,21 +199,12 @@ void QPainterPrivate::checkEmulation()
     if (state->bgMode == Qt::OpaqueMode)
         doEmulation = true;
 
-    const QGradient *bg = state->brush.gradient();
-    if (bg && bg->coordinateMode() > QGradient::LogicalMode)
+    if (needsEmulation(state->brush))
         doEmulation = true;
 
-    const QGradient *pg = qpen_brush(state->pen).gradient();
-    if (pg && pg->coordinateMode() > QGradient::LogicalMode)
+    if (needsEmulation(qpen_brush(state->pen)))
         doEmulation = true;
 
-    if (state->brush.style() == Qt::TexturePattern) {
-        if (qHasPixmapTexture(state->brush))
-            doEmulation |= !qFuzzyCompare(state->brush.texture().devicePixelRatioF(), 1.0);
-        else
-            doEmulation |= !qFuzzyCompare(state->brush.textureImage().devicePixelRatioF(), 1.0);
-    }
-
     if (doEmulation && extended->flags() & QPaintEngineEx::DoNotEmulate)
         return;
 
@@ -3319,12 +3327,9 @@ void QPainter::strokePath(const QPainterPath &path, const QPen &pen)
     if (path.isEmpty())
         return;
 
-    if (d->extended) {
-        const QGradient *g = qpen_brush(pen).gradient();
-        if (!g || g->coordinateMode() == QGradient::LogicalMode) {
-            d->extended->stroke(qtVectorPathForPath(path), pen);
-            return;
-        }
+    if (d->extended && !needsEmulation(pen.brush())) {
+        d->extended->stroke(qtVectorPathForPath(path), pen);
+        return;
     }
 
     QBrush oldBrush = d->state->brush;
@@ -3362,12 +3367,9 @@ void QPainter::fillPath(const QPainterPath &path, const QBrush &brush)
     if (path.isEmpty())
         return;
 
-    if (d->extended) {
-        const QGradient *g = brush.gradient();
-        if (!g || g->coordinateMode() == QGradient::LogicalMode) {
-            d->extended->fill(qtVectorPathForPath(path), brush);
-            return;
-        }
+    if (d->extended && !needsEmulation(brush)) {
+        d->extended->fill(qtVectorPathForPath(path), brush);
+        return;
     }
 
     QBrush oldBrush = d->state->brush;
@@ -6956,12 +6958,9 @@ void QPainter::fillRect(const QRectF &r, const QBrush &brush)
     if (!d->engine)
         return;
 
-    if (d->extended) {
-        const QGradient *g = brush.gradient();
-        if (!g || g->coordinateMode() == QGradient::LogicalMode) {
-            d->extended->fillRect(r, brush);
-            return;
-        }
+    if (d->extended && !needsEmulation(brush)) {
+        d->extended->fillRect(r, brush);
+        return;
     }
 
     QPen oldPen = pen();
@@ -6994,12 +6993,9 @@ void QPainter::fillRect(const QRect &r, const QBrush &brush)
     if (!d->engine)
         return;
 
-    if (d->extended) {
-        const QGradient *g = brush.gradient();
-        if (!g || g->coordinateMode() == QGradient::LogicalMode) {
-            d->extended->fillRect(r, brush);
-            return;
-        }
+    if (d->extended && !needsEmulation(brush)) {
+        d->extended->fillRect(r, brush);
+        return;
     }
 
     QPen oldPen = pen();
diff --git a/src/gui/text/qfontdatabase.cpp b/src/gui/text/qfontdatabase.cpp
index cf716df669..a657a8c516 100644
--- a/src/gui/text/qfontdatabase.cpp
+++ b/src/gui/text/qfontdatabase.cpp
@@ -2509,13 +2509,12 @@ bool QFontDatabasePrivate::isApplicationFont(const QString &fileName)
     with removeApplicationFont() or to retrieve the list of family names contained
     in the font.
 
+//! [add-application-font-doc]
     The function returns -1 if the font could not be loaded.
 
     Currently only TrueType fonts, TrueType font collections, and OpenType fonts are
     supported.
-
-    \note Adding application fonts on Unix/X11 platforms without fontconfig is
-    currently not supported.
+//! [add-application-font-doc]
 
     \sa addApplicationFontFromData(), applicationFontFamilies(), removeApplicationFont()
 */
@@ -2543,12 +2542,7 @@ int QFontDatabase::addApplicationFont(const QString &fileName)
     with removeApplicationFont() or to retrieve the list of family names contained
     in the font.
 
-    The function returns -1 if the font could not be loaded.
-
-    Currently only TrueType fonts and TrueType font collections are supported.
-
-    \b{Note:} Adding application fonts on Unix/X11 platforms without fontconfig is
-    currently not supported.
+    \include qfontdatabase.cpp add-application-font-doc
 
     \sa addApplicationFont(), applicationFontFamilies(), removeApplicationFont()
 */
diff --git a/src/gui/text/qtextdocument_p.cpp b/src/gui/text/qtextdocument_p.cpp
index 524931ebde..c22dd95d48 100644
--- a/src/gui/text/qtextdocument_p.cpp
+++ b/src/gui/text/qtextdocument_p.cpp
@@ -381,8 +381,11 @@ int QTextDocumentPrivate::insert_block(int pos, uint strPos, int format, int blo
     Q_ASSERT(blocks.length() == fragments.length());
 
     QTextBlockGroup *group = qobject_cast<QTextBlockGroup *>(objectForFormat(blockFormat));
-    if (group)
+    if (group) {
         group->blockInserted(QTextBlock(this, b));
+        docChangeOldLength--;
+        docChangeLength--;
+    }
 
     QTextFrame *frame = qobject_cast<QTextFrame *>(objectForFormat(formats.format(format)));
     if (frame) {
diff --git a/src/gui/text/qtextdocumentlayout.cpp b/src/gui/text/qtextdocumentlayout.cpp
index ba72e26c3f..f3e6ea2100 100644
--- a/src/gui/text/qtextdocumentlayout.cpp
+++ b/src/gui/text/qtextdocumentlayout.cpp
@@ -2361,9 +2361,10 @@ QTextLayoutStruct QTextDocumentLayoutPrivate::layoutCell(QTextTable *t, const QT
         floatMinWidth = qMax(floatMinWidth, cd->minimumWidth);
     }
 
-    // constraint the maximumWidth by the minimum width of the fixed size floats, to
-    // keep them visible
+    // constraint the maximum/minimumWidth by the minimum width of the fixed size floats,
+    // to keep them visible
     layoutStruct.maximumWidth = qMax(layoutStruct.maximumWidth, floatMinWidth);
+    layoutStruct.minimumWidth = qMax(layoutStruct.minimumWidth, floatMinWidth);
 
     // as floats in cells get added to the table's float list but must not affect
     // floats in other cells we must clear the list here.
@@ -2540,6 +2541,8 @@ recalc_minmax_widths:
             for (int n = 0; n < cspan; ++n) {
                 const int col = i + n;
                 QFixed w = widthToDistribute / (cspan - n);
+                if (td->maxWidths[col] != QFIXED_MAX)
+                    w = qMax(td->maxWidths[col], w);
                 td->maxWidths[col] = qMax(td->minWidths.at(col), w);
                 widthToDistribute -= td->maxWidths.at(col);
                 if (widthToDistribute <= 0)
diff --git a/src/gui/text/qtextengine.cpp b/src/gui/text/qtextengine.cpp
index 805ab87dd6..ce4abac472 100644
--- a/src/gui/text/qtextengine.cpp
+++ b/src/gui/text/qtextengine.cpp
@@ -1373,9 +1373,15 @@ static void applyVisibilityRules(ushort ucs, QGlyphLayout *glyphs, uint glyphPos
         if (!fontEngine->symbol) {
             // U+00AD [SOFT HYPHEN] is a default ignorable codepoint,
             // so we replace its glyph and metrics with ones for
-            // U+002D [HYPHEN-MINUS] and make it visible if it appears at line-break
+            // U+002D [HYPHEN-MINUS] or U+2010 [HYPHEN] and make
+            // it visible if it appears at line-break
             const uint engineIndex = glyphs->glyphs[glyphPosition] & 0xff000000;
-            glyphs->glyphs[glyphPosition] = fontEngine->glyphIndex('-');
+            glyph_t glyph = fontEngine->glyphIndex(0x002d);
+            if (glyph == 0)
+                glyph = fontEngine->glyphIndex(0x2010);
+            if (glyph == 0)
+                glyph = fontEngine->glyphIndex(0x00ad);
+            glyphs->glyphs[glyphPosition] = glyph;
             if (Q_LIKELY(glyphs->glyphs[glyphPosition] != 0)) {
                 glyphs->glyphs[glyphPosition] |= engineIndex;
                 QGlyphLayout tmp = glyphs->mid(glyphPosition, 1);