Merge remote branch 'staging/master' into refactor

Conflicts:
	src/gui/painting/qdrawhelper_p.h
	src/gui/painting/qgraphicssystemfactory.cpp
	src/gui/painting/qpainter.cpp
	src/gui/painting/qunifiedtoolbarsurface_mac.cpp
	src/gui/painting/qunifiedtoolbarsurface_mac_p.h
	src/openvg/openvg.pro
	src/openvg/qpaintengine_vg.cpp
	src/openvg/qwindowsurface_vg.cpp
	src/openvg/qwindowsurface_vgegl.cpp
	src/plugins/platforms/wayland/qwaylanddisplay.cpp
	src/widgets/graphicsview/qgraphicsscene.cpp

31 files changed, 946 insertions, 470 deletions

diff --git a/src/gui/guikernel/qclipboard.h b/src/gui/guikernel/qclipboard.h
index 0a9e28ac8c..989ba19c2c 100644
--- a/src/gui/guikernel/qclipboard.h
+++ b/src/gui/guikernel/qclipboard.h
@@ -113,6 +113,7 @@ protected:
     friend class QBaseApplication;
     friend class QDragManager;
     friend class QMimeSource;
+    friend class QPlatformClipboard;
 
 private:
     Q_DISABLE_COPY(QClipboard)
diff --git a/src/gui/guikernel/qplatformclipboard_qpa.cpp b/src/gui/guikernel/qplatformclipboard_qpa.cpp
index 957a4dfd2e..302df683bd 100644
--- a/src/gui/guikernel/qplatformclipboard_qpa.cpp
+++ b/src/gui/guikernel/qplatformclipboard_qpa.cpp
@@ -42,6 +42,8 @@
 
 #ifndef QT_NO_CLIPBOARD
 
+#include <QtGui/private/qapplication_p.h>
+
 QT_BEGIN_NAMESPACE
 
 class QClipboardData
@@ -81,7 +83,7 @@ QPlatformClipboard::~QPlatformClipboard()
 
 }
 
-const QMimeData *QPlatformClipboard::mimeData(QClipboard::Mode mode) const
+QMimeData *QPlatformClipboard::mimeData(QClipboard::Mode mode)
 {
     //we know its clipboard
     Q_UNUSED(mode);
@@ -100,6 +102,11 @@ bool QPlatformClipboard::supportsMode(QClipboard::Mode mode) const
     return mode == QClipboard::Clipboard;
 }
 
+void QPlatformClipboard::emitChanged(QClipboard::Mode mode)
+{
+    QApplication::clipboard()->emitChanged(mode);
+}
+
 QT_END_NAMESPACE
 
 #endif //QT_NO_CLIPBOARD
diff --git a/src/gui/guikernel/qplatformclipboard_qpa.h b/src/gui/guikernel/qplatformclipboard_qpa.h
index 3381c062b8..e1be8aa22f 100644
--- a/src/gui/guikernel/qplatformclipboard_qpa.h
+++ b/src/gui/guikernel/qplatformclipboard_qpa.h
@@ -59,9 +59,10 @@ class Q_GUI_EXPORT QPlatformClipboard
 public:
     virtual ~QPlatformClipboard();
 
-    virtual const QMimeData *mimeData(QClipboard::Mode mode = QClipboard::Clipboard ) const;
+    virtual QMimeData *mimeData(QClipboard::Mode mode = QClipboard::Clipboard);
     virtual void setMimeData(QMimeData *data, QClipboard::Mode mode = QClipboard::Clipboard);
     virtual bool supportsMode(QClipboard::Mode mode) const;
+    void emitChanged(QClipboard::Mode mode);
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
index da0a10409a..21640ca4bb 100644
--- a/src/gui/image/qpixmap.cpp
+++ b/src/gui/image/qpixmap.cpp
@@ -1156,12 +1156,8 @@ Qt::HANDLE QPixmap::handle() const
 {
 #if defined(Q_WS_X11)
     const QPixmapData *pd = pixmapData();
-    if (pd) {
-        if (pd->classId() == QPixmapData::X11Class)
-            return static_cast<const QX11PixmapData*>(pd)->handle();
-        else
-            qWarning("QPixmap::handle(): Pixmap is not an X11 class pixmap");
-    }
+    if (pd && pd->classId() == QPixmapData::X11Class)
+        return static_cast<const QX11PixmapData*>(pd)->handle();
 #endif
     return 0;
 }
diff --git a/src/gui/painting/qbrush.cpp b/src/gui/painting/qbrush.cpp
index aec03bc544..b5320dd6cb 100644
--- a/src/gui/painting/qbrush.cpp
+++ b/src/gui/painting/qbrush.cpp
@@ -810,6 +810,22 @@ const QGradient *QBrush::gradient() const
     return 0;
 }
 
+Q_GUI_EXPORT bool qt_isExtendedRadialGradient(const QBrush &brush)
+{
+    if (brush.style() == Qt::RadialGradientPattern) {
+        const QGradient *g = brush.gradient();
+        const QRadialGradient *rg = static_cast<const QRadialGradient *>(g);
+
+        if (!qFuzzyIsNull(rg->focalRadius()))
+            return true;
+
+        QPointF delta = rg->focalPoint() - rg->center();
+        if (delta.x() * delta.x() + delta.y() * delta.y() > rg->radius() * rg->radius())
+            return true;
+    }
+
+    return false;
+}
 
 /*!
     Returns true if the brush is fully opaque otherwise false. A brush
@@ -819,6 +835,7 @@ const QGradient *QBrush::gradient() const
     \i The alpha component of the color() is 255.
     \i Its texture() does not have an alpha channel and is not a QBitmap.
     \i The colors in the gradient() all have an alpha component that is 255.
+    \i It is an extended radial gradient.
     \endlist
 */
 
@@ -830,6 +847,9 @@ bool QBrush::isOpaque() const
     if (d->style == Qt::SolidPattern)
         return opaqueColor;
 
+    if (qt_isExtendedRadialGradient(*this))
+        return false;
+
     if (d->style == Qt::LinearGradientPattern
         || d->style == Qt::RadialGradientPattern
         || d->style == Qt::ConicalGradientPattern) {
@@ -1179,8 +1199,10 @@ QDataStream &operator>>(QDataStream &s, QBrush &b)
 
     \list
     \o \e Linear gradients interpolate colors between start and end points.
-    \o \e Radial gradients interpolate colors between a focal point and end
-        points on a circle surrounding it.
+    \o \e Simple radial gradients interpolate colors between a focal point
+        and end points on a circle surrounding it.
+    \o \e Extended radial gradients interpolate colors between a center and
+        a focal circle.
     \o \e Conical gradients interpolate colors around a center point.
     \endlist
 
@@ -1476,8 +1498,6 @@ void QGradient::setInterpolationMode(InterpolationMode mode)
     dummy = p;
 }
 
-#undef Q_DUMMY_ACCESSOR
-
 /*!
     \fn bool QGradient::operator!=(const QGradient &gradient) const
     \since 4.2
@@ -1511,7 +1531,7 @@ bool QGradient::operator==(const QGradient &gradient) const
             || m_data.radial.cy != gradient.m_data.radial.cy
             || m_data.radial.fx != gradient.m_data.radial.fx
             || m_data.radial.fy != gradient.m_data.radial.fy
-            || m_data.radial.radius != gradient.m_data.radial.radius)
+            || m_data.radial.cradius != gradient.m_data.radial.cradius)
             return false;
     } else { // m_type == ConicalGradient
         if (m_data.conical.cx != gradient.m_data.conical.cx
@@ -1717,10 +1737,17 @@ void QLinearGradient::setFinalStop(const QPointF &stop)
     \brief The QRadialGradient class is used in combination with QBrush to
     specify a radial gradient brush.
 
-    Radial gradients interpolate colors between a focal point and end
-    points on a circle surrounding it. Outside the end points the
-    gradient is either padded, reflected or repeated depending on the
-    currently set \l {QGradient::Spread}{spread} method:
+    Qt supports both simple and extended radial gradients.
+
+    Simple radial gradients interpolate colors between a focal point and end
+    points on a circle surrounding it. Extended radial gradients interpolate
+    colors between a focal circle and a center circle. Points outside the cone
+    defined by the two circles will be transparent. For simple radial gradients
+    the focal point is adjusted to lie inside the center circle, whereas the
+    focal point can have any position in an extended radial gradient.
+
+    Outside the end points the gradient is either padded, reflected or repeated
+    depending on the currently set \l {QGradient::Spread}{spread} method:
 
     \table
     \row
@@ -1765,9 +1792,14 @@ static QPointF qt_radial_gradient_adapt_focal_point(const QPointF &center,
 }
 
 /*!
-    Constructs a radial gradient with the given \a center, \a
+    Constructs a simple radial gradient with the given \a center, \a
     radius and \a focalPoint.
 
+    \note If the given focal point is outside the circle defined by the
+    center (\a cx, \a cy) and the \a radius it will be re-adjusted to
+    the intersection between the line from the center to the focal point
+    and the circle.
+
     \sa QGradient::setColorAt(), QGradient::setStops()
 */
 
@@ -1777,7 +1809,7 @@ QRadialGradient::QRadialGradient(const QPointF &center, qreal radius, const QPoi
     m_spread = PadSpread;
     m_data.radial.cx = center.x();
     m_data.radial.cy = center.y();
-    m_data.radial.radius = radius;
+    m_data.radial.cradius = radius;
 
     QPointF adapted_focal = qt_radial_gradient_adapt_focal_point(center, radius, focalPoint);
     m_data.radial.fx = adapted_focal.x();
@@ -1785,7 +1817,7 @@ QRadialGradient::QRadialGradient(const QPointF &center, qreal radius, const QPoi
 }
 
 /*!
-    Constructs a radial gradient with the given \a center, \a
+    Constructs a simple radial gradient with the given \a center, \a
     radius and the focal point in the circle center.
 
     \sa QGradient::setColorAt(), QGradient::setStops()
@@ -1796,16 +1828,21 @@ QRadialGradient::QRadialGradient(const QPointF &center, qreal radius)
     m_spread = PadSpread;
     m_data.radial.cx = center.x();
     m_data.radial.cy = center.y();
-    m_data.radial.radius = radius;
+    m_data.radial.cradius = radius;
     m_data.radial.fx = center.x();
     m_data.radial.fy = center.y();
 }
 
 
 /*!
-    Constructs a radial gradient with the given center (\a cx, \a cy),
+    Constructs a simple radial gradient with the given center (\a cx, \a cy),
     \a radius and focal point (\a fx, \a fy).
 
+    \note If the given focal point is outside the circle defined by the
+    center (\a cx, \a cy) and the \a radius it will be re-adjusted to
+    the intersection between the line from the center to the focal point
+    and the circle.
+
     \sa QGradient::setColorAt(), QGradient::setStops()
 */
 
@@ -1815,7 +1852,7 @@ QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal radius, qreal fx, qre
     m_spread = PadSpread;
     m_data.radial.cx = cx;
     m_data.radial.cy = cy;
-    m_data.radial.radius = radius;
+    m_data.radial.cradius = radius;
 
     QPointF adapted_focal = qt_radial_gradient_adapt_focal_point(QPointF(cx, cy),
                                                                  radius,
@@ -1826,7 +1863,7 @@ QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal radius, qreal fx, qre
 }
 
 /*!
-    Constructs a radial gradient with the center at (\a cx, \a cy) and the
+    Constructs a simple radial gradient with the center at (\a cx, \a cy) and the
     specified \a radius. The focal point lies at the center of the circle.
 
     \sa QGradient::setColorAt(), QGradient::setStops()
@@ -1837,14 +1874,14 @@ QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal radius)
     m_spread = PadSpread;
     m_data.radial.cx = cx;
     m_data.radial.cy = cy;
-    m_data.radial.radius = radius;
+    m_data.radial.cradius = radius;
     m_data.radial.fx = cx;
     m_data.radial.fy = cy;
 }
 
 
 /*!
-    Constructs a radial gradient with the center and focal point at
+    Constructs a simple radial gradient with the center and focal point at
     (0, 0) with a radius of 1.
 */
 QRadialGradient::QRadialGradient()
@@ -1853,11 +1890,51 @@ QRadialGradient::QRadialGradient()
     m_spread = PadSpread;
     m_data.radial.cx = 0;
     m_data.radial.cy = 0;
-    m_data.radial.radius = 1;
+    m_data.radial.cradius = 1;
     m_data.radial.fx = 0;
     m_data.radial.fy = 0;
 }
 
+/*!
+    \since 4.8
+
+    Constructs an extended radial gradient with the given \a center, \a
+    centerRadius, \a focalPoint, and \a focalRadius.
+*/
+QRadialGradient::QRadialGradient(const QPointF &center, qreal centerRadius, const QPointF &focalPoint, qreal focalRadius)
+{
+    m_type = RadialGradient;
+    m_spread = PadSpread;
+    m_data.radial.cx = center.x();
+    m_data.radial.cy = center.y();
+    m_data.radial.cradius = centerRadius;
+
+    m_data.radial.fx = focalPoint.x();
+    m_data.radial.fy = focalPoint.y();
+    setFocalRadius(focalRadius);
+}
+
+/*!
+    \since 4.8
+
+    Constructs an extended radial gradient with the given \a center, \a
+    centerRadius, \a focalPoint, and \a focalRadius.
+    Constructs a radial gradient with the given center (\a cx, \a cy),
+    center radius \a centerRadius, focal point (\a fx, \a fy), and
+    focal radius \a focalRadius.
+*/
+QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal centerRadius, qreal fx, qreal fy, qreal focalRadius)
+{
+    m_type = RadialGradient;
+    m_spread = PadSpread;
+    m_data.radial.cx = cx;
+    m_data.radial.cy = cy;
+    m_data.radial.cradius = centerRadius;
+
+    m_data.radial.fx = fx;
+    m_data.radial.fy = fy;
+    setFocalRadius(focalRadius);
+}
 
 /*!
     Returns the center of this radial gradient in logical coordinates.
@@ -1902,13 +1979,15 @@ void QRadialGradient::setCenter(const QPointF &center)
 /*!
     Returns the radius of this radial gradient in logical coordinates.
 
+    Equivalent to centerRadius()
+
     \sa QGradient::stops()
 */
 
 qreal QRadialGradient::radius() const
 {
     Q_ASSERT(m_type == RadialGradient);
-    return m_data.radial.radius;
+    return m_data.radial.cradius;
 }
 
 
@@ -1917,13 +1996,81 @@ qreal QRadialGradient::radius() const
 
     Sets the radius of this radial gradient in logical coordinates
     to \a radius
+
+    Equivalent to setCenterRadius()
 */
 void QRadialGradient::setRadius(qreal radius)
 {
     Q_ASSERT(m_type == RadialGradient);
-    m_data.radial.radius = radius;
+    m_data.radial.cradius = radius;
+}
+
+/*!
+    \since 4.8
+
+    Returns the center radius of this radial gradient in logical
+    coordinates.
+
+    \sa QGradient::stops()
+*/
+qreal QRadialGradient::centerRadius() const
+{
+    Q_ASSERT(m_type == RadialGradient);
+    return m_data.radial.cradius;
+}
+
+/*
+   \since 4.8
+
+   Sets the center radius of this radial gradient in logical coordinates
+   to \a radius
+*/
+void QRadialGradient::setCenterRadius(qreal radius)
+{
+    Q_ASSERT(m_type == RadialGradient);
+    m_data.radial.cradius = radius;
+}
+
+/*!
+    \since 4.8
+
+    Returns the focal radius of this radial gradient in logical
+    coordinates.
+
+    \sa QGradient::stops()
+*/
+qreal QRadialGradient::focalRadius() const
+{
+    Q_ASSERT(m_type == RadialGradient);
+    Q_DUMMY_ACCESSOR
+
+    // mask away low three bits
+    union { float f; quint32 i; } u;
+    u.i = i & ~0x07;
+    return u.f;
 }
 
+/*
+   \since 4.8
+
+   Sets the focal radius of this radial gradient in logical coordinates
+   to \a radius
+*/
+void QRadialGradient::setFocalRadius(qreal radius)
+{
+    Q_ASSERT(m_type == RadialGradient);
+    Q_DUMMY_ACCESSOR
+
+    // Since there's no QGradientData, we only have the dummy void * to
+    // store additional data in. The three lowest bits are already
+    // taken, thus we cut the three lowest bits from the significand
+    // and store the radius as a float.
+    union { float f; quint32 i; } u;
+    u.f = float(radius);
+    // add 0x04 to round up when we drop the three lowest bits
+    i |= (u.i + 0x04) & ~0x07;
+    dummy = p;
+}
 
 /*!
     Returns the focal point of this radial gradient in logical
@@ -2163,4 +2310,6 @@ void QConicalGradient::setAngle(qreal angle)
     \sa setTransform()
 */
 
+#undef Q_DUMMY_ACCESSOR
+
 QT_END_NAMESPACE
diff --git a/src/gui/painting/qbrush.h b/src/gui/painting/qbrush.h
index 89be376ad9..e399a4e3ae 100644
--- a/src/gui/painting/qbrush.h
+++ b/src/gui/painting/qbrush.h
@@ -245,6 +245,7 @@ private:
     friend class QLinearGradient;
     friend class QRadialGradient;
     friend class QConicalGradient;
+    friend class QBrush;
 
     Type m_type;
     Spread m_spread;
@@ -254,7 +255,7 @@ private:
             qreal x1, y1, x2, y2;
         } linear;
         struct {
-            qreal cx, cy, fx, fy, radius;
+            qreal cx, cy, fx, fy, cradius;
         } radial;
         struct {
             qreal cx, cy, angle;
@@ -293,6 +294,9 @@ public:
     QRadialGradient(const QPointF &center, qreal radius);
     QRadialGradient(qreal cx, qreal cy, qreal radius);
 
+    QRadialGradient(const QPointF &center, qreal centerRadius, const QPointF &focalPoint, qreal focalRadius);
+    QRadialGradient(qreal cx, qreal cy, qreal centerRadius, qreal fx, qreal fy, qreal focalRadius);
+
     QPointF center() const;
     void setCenter(const QPointF &center);
     inline void setCenter(qreal x, qreal y) { setCenter(QPointF(x, y)); }
@@ -303,6 +307,12 @@ public:
 
     qreal radius() const;
     void setRadius(qreal radius);
+
+    qreal centerRadius() const;
+    void setCenterRadius(qreal radius);
+
+    qreal focalRadius() const;
+    void setFocalRadius(qreal radius);
 };
 
 
diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp
index 333b433bb5..5e23f5f6fd 100644
--- a/src/gui/painting/qdrawhelper.cpp
+++ b/src/gui/painting/qdrawhelper.cpp
@@ -75,43 +75,9 @@ enum {
     fixed_scale = 1 << 16,
     half_point = 1 << 15
 };
-static const int buffer_size = 2048;
-
-struct LinearGradientValues
-{
-    qreal dx;
-    qreal dy;
-    qreal l;
-    qreal off;
-};
-
-struct RadialGradientValues
-{
-    qreal dx;
-    qreal dy;
-    qreal a;
-};
-
-struct Operator;
-typedef uint* (QT_FASTCALL *DestFetchProc)(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length);
-typedef void (QT_FASTCALL *DestStoreProc)(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length);
-typedef const uint* (QT_FASTCALL *SourceFetchProc)(uint *buffer, const Operator *o, const QSpanData *data, int y, int x, int length);
-
 
-struct Operator
-{
-    QPainter::CompositionMode mode;
-    DestFetchProc dest_fetch;
-    DestStoreProc dest_store;
-    SourceFetchProc src_fetch;
-    CompositionFunctionSolid funcSolid;
-    CompositionFunction func;
-    union {
-        LinearGradientValues linear;
-        RadialGradientValues radial;
-//        TextureValues texture;
-    };
-};
+// must be multiple of 4 for easier SIMD implementations
+static const int buffer_size = 2048;
 
 /*
   Destination fetch. This is simple as we don't have to do bounds checks or
@@ -1346,64 +1312,13 @@ static const SourceFetchProc sourceFetch[NBlendTypes][QImage::NImageFormats] = {
     },
 };
 
-
-static inline uint qt_gradient_pixel(const QGradientData *data, qreal pos)
-{
-    int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + qreal(0.5));
-
-  // calculate the actual offset.
-    if (ipos < 0 || ipos >= GRADIENT_STOPTABLE_SIZE) {
-        if (data->spread == QGradient::RepeatSpread) {
-            ipos = ipos % GRADIENT_STOPTABLE_SIZE;
-            ipos = ipos < 0 ? GRADIENT_STOPTABLE_SIZE + ipos : ipos;
-
-        } else if (data->spread == QGradient::ReflectSpread) {
-            const int limit = GRADIENT_STOPTABLE_SIZE * 2 - 1;
-            ipos = ipos % limit;
-            ipos = ipos < 0 ? limit + ipos : ipos;
-            ipos = ipos >= GRADIENT_STOPTABLE_SIZE ? limit - ipos : ipos;
-
-        } else {
-            if (ipos < 0) ipos = 0;
-            else if (ipos >= GRADIENT_STOPTABLE_SIZE) ipos = GRADIENT_STOPTABLE_SIZE-1;
-        }
-    }
-
-    Q_ASSERT(ipos >= 0);
-    Q_ASSERT(ipos < GRADIENT_STOPTABLE_SIZE);
-
-    return data->colorTable[ipos];
-}
-
 #define FIXPT_BITS 8
 #define FIXPT_SIZE (1<<FIXPT_BITS)
 
 static uint qt_gradient_pixel_fixed(const QGradientData *data, int fixed_pos)
 {
     int ipos = (fixed_pos + (FIXPT_SIZE / 2)) >> FIXPT_BITS;
-
-    // calculate the actual offset.
-    if (ipos < 0 || ipos >= GRADIENT_STOPTABLE_SIZE) {
-        if (data->spread == QGradient::RepeatSpread) {
-            ipos = ipos % GRADIENT_STOPTABLE_SIZE;
-            ipos = ipos < 0 ? GRADIENT_STOPTABLE_SIZE + ipos : ipos;
-
-        } else if (data->spread == QGradient::ReflectSpread) {
-            const int limit = GRADIENT_STOPTABLE_SIZE * 2 - 1;
-            ipos = ipos % limit;
-            ipos = ipos < 0 ? limit + ipos : ipos;
-            ipos = ipos >= GRADIENT_STOPTABLE_SIZE ? limit - ipos : ipos;
-
-        } else {
-            if (ipos < 0) ipos = 0;
-            else if (ipos >= GRADIENT_STOPTABLE_SIZE) ipos = GRADIENT_STOPTABLE_SIZE-1;
-        }
-    }
-
-    Q_ASSERT(ipos >= 0);
-    Q_ASSERT(ipos < GRADIENT_STOPTABLE_SIZE);
-
-    return data->colorTable[ipos];
+    return data->colorTable[qt_gradient_clamp(data, ipos)];
 }
 
 static void QT_FASTCALL getLinearGradientValues(LinearGradientValues *v, const QSpanData *data)
@@ -1419,8 +1334,8 @@ static void QT_FASTCALL getLinearGradientValues(LinearGradientValues *v, const Q
     }
 }
 
-static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator *op, const QSpanData *data,
-                                                    int y, int x, int length)
+static const uint * QT_FASTCALL qt_fetch_linear_gradient(uint *buffer, const Operator *op, const QSpanData *data,
+                                                         int y, int x, int length)
 {
     const uint *b = buffer;
     qreal t, inc;
@@ -1487,110 +1402,65 @@ static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator
     return b;
 }
 
-static inline qreal determinant(qreal a, qreal b, qreal c)
-{
-    return (b * b) - (4 * a * c);
-}
-
-// function to evaluate real roots
-static inline qreal realRoots(qreal a, qreal b, qreal detSqrt)
-{
-    return (-b + detSqrt)/(2 * a);
-}
-
-static inline qreal qSafeSqrt(qreal x)
-{
-    return x > 0 ? qSqrt(x) : 0;
-}
-
 static void QT_FASTCALL getRadialGradientValues(RadialGradientValues *v, const QSpanData *data)
 {
     v->dx = data->gradient.radial.center.x - data->gradient.radial.focal.x;
     v->dy = data->gradient.radial.center.y - data->gradient.radial.focal.y;
-    v->a = data->gradient.radial.radius*data->gradient.radial.radius - v->dx*v->dx - v->dy*v->dy;
-}
-
-static const uint * QT_FASTCALL fetchRadialGradient(uint *buffer, const Operator *op, const QSpanData *data,
-                                                    int y, int x, int length)
-{
-    const uint *b = buffer;
-    qreal rx = data->m21 * (y + qreal(0.5))
-               + data->dx + data->m11 * (x + qreal(0.5));
-    qreal ry = data->m22 * (y + qreal(0.5))
-               + data->dy + data->m12 * (x + qreal(0.5));
-    bool affine = !data->m13 && !data->m23;
-    //qreal r  = data->gradient.radial.radius;
-
-    const uint *end = buffer + length;
-    if (affine) {
-        rx -= data->gradient.radial.focal.x;
-        ry -= data->gradient.radial.focal.y;
-
-        qreal inv_a = 1 / qreal(2 * op->radial.a);
-
-        const qreal delta_rx = data->m11;
-        const qreal delta_ry = data->m12;
 
-        qreal b = 2*(rx * op->radial.dx + ry * op->radial.dy);
-        qreal delta_b = 2*(delta_rx * op->radial.dx + delta_ry * op->radial.dy);
-        const qreal b_delta_b = 2 * b * delta_b;
-        const qreal delta_b_delta_b = 2 * delta_b * delta_b;
+    v->dr = data->gradient.radial.center.radius - data->gradient.radial.focal.radius;
+    v->sqrfr = data->gradient.radial.focal.radius * data->gradient.radial.focal.radius;
 
-        const qreal bb = b * b;
-        const qreal delta_bb = delta_b * delta_b;
+    v->a = v->dr * v->dr - v->dx*v->dx - v->dy*v->dy;
+    v->inv2a = 1 / (2 * v->a);
 
-        b *= inv_a;
-        delta_b *= inv_a;
-
-        const qreal rxrxryry = rx * rx + ry * ry;
-        const qreal delta_rxrxryry = delta_rx * delta_rx + delta_ry * delta_ry;
-        const qreal rx_plus_ry = 2*(rx * delta_rx + ry * delta_ry);
-        const qreal delta_rx_plus_ry = 2 * delta_rxrxryry;
-
-        inv_a *= inv_a;
+    v->extended = !qFuzzyIsNull(data->gradient.radial.focal.radius) || v->a <= 0;
+}
 
-        qreal det = (bb + 4 * op->radial.a * rxrxryry) * inv_a;
-        qreal delta_det = (b_delta_b + delta_bb + 4 * op->radial.a * (rx_plus_ry + delta_rxrxryry)) * inv_a;
-        const qreal delta_delta_det = (delta_b_delta_b + 4 * op->radial.a * delta_rx_plus_ry) * inv_a;
+class RadialFetchPlain
+{
+public:
+    static inline void fetch(uint *buffer, uint *end, const Operator *op, const QSpanData *data, qreal det,
+                             qreal delta_det, qreal delta_delta_det, qreal b, qreal delta_b)
+    {
+        if (op->radial.extended) {
+            while (buffer < end) {
+                quint32 result = 0;
+                if (det >= 0) {
+                    qreal w = qSqrt(det) - b;
+                    if (data->gradient.radial.focal.radius + op->radial.dr * w >= 0)
+                        result = qt_gradient_pixel(&data->gradient, w);
+                }
 
-        while (buffer < end) {
-            *buffer = qt_gradient_pixel(&data->gradient, qSafeSqrt(det) - b);
+                *buffer = result;
 
-            det += delta_det;
-            delta_det += delta_delta_det;
-            b += delta_b;
+                det += delta_det;
+                delta_det += delta_delta_det;
+                b += delta_b;
 
-            ++buffer;
-        }
-    } else {
-        qreal rw = data->m23 * (y + qreal(0.5))
-                   + data->m33 + data->m13 * (x + qreal(0.5));
-        if (!rw)
-            rw = 1;
-        while (buffer < end) {
-            qreal gx = rx/rw - data->gradient.radial.focal.x;
-            qreal gy = ry/rw - data->gradient.radial.focal.y;
-            qreal b  = 2*(gx*op->radial.dx + gy*op->radial.dy);
-            qreal det = determinant(op->radial.a, b , -(gx*gx + gy*gy));
-            qreal s = realRoots(op->radial.a, b, qSafeSqrt(det));
-
-            *buffer = qt_gradient_pixel(&data->gradient, s);
+                ++buffer;
+            }
+        } else {
+            while (buffer < end) {
+                *buffer++ = qt_gradient_pixel(&data->gradient, qSqrt(det) - b);
 
-            rx += data->m11;
-            ry += data->m12;
-            rw += data->m13;
-            if (!rw) {
-                rw += data->m13;
+                det += delta_det;
+                delta_det += delta_delta_det;
+                b += delta_b;
             }
-            ++buffer;
         }
     }
+};
 
-    return b;
+const uint * QT_FASTCALL qt_fetch_radial_gradient_plain(uint *buffer, const Operator *op, const QSpanData *data,
+                                                        int y, int x, int length)
+{
+    return qt_fetch_radial_gradient_template<RadialFetchPlain>(buffer, op, data, y, x, length);
 }
 
-static const uint * QT_FASTCALL fetchConicalGradient(uint *buffer, const Operator *, const QSpanData *data,
-                                                     int y, int x, int length)
+static SourceFetchProc qt_fetch_radial_gradient = qt_fetch_radial_gradient_plain;
+
+static const uint * QT_FASTCALL qt_fetch_conical_gradient(uint *buffer, const Operator *, const QSpanData *data,
+                                                          int y, int x, int length)
 {
     const uint *b = buffer;
     qreal rx = data->m21 * (y + qreal(0.5))
@@ -3347,16 +3217,16 @@ static inline Operator getOperator(const QSpanData *data, const QSpan *spans, in
     case QSpanData::LinearGradient:
         solidSource = !data->gradient.alphaColor;
         getLinearGradientValues(&op.linear, data);
-        op.src_fetch = fetchLinearGradient;
+        op.src_fetch = qt_fetch_linear_gradient;
         break;
     case QSpanData::RadialGradient:
         solidSource = !data->gradient.alphaColor;
         getRadialGradientValues(&op.radial, data);
-        op.src_fetch = fetchRadialGradient;
+        op.src_fetch = qt_fetch_radial_gradient;
         break;
     case QSpanData::ConicalGradient:
         solidSource = !data->gradient.alphaColor;
-        op.src_fetch = fetchConicalGradient;
+        op.src_fetch = qt_fetch_conical_gradient;
         break;
     case QSpanData::Texture:
         op.src_fetch = sourceFetch[getBlendType(data)][data->texture.format];
@@ -7278,6 +7148,11 @@ void qInitDrawhelperAsm()
         qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_sse2;
         qBlendFunctions[QImage::Format_RGB32][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_sse2;
         qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_sse2;
+
+        extern const uint * QT_FASTCALL qt_fetch_radial_gradient_sse2(uint *buffer, const Operator *op, const QSpanData *data,
+                                                                      int y, int x, int length);
+
+        qt_fetch_radial_gradient = qt_fetch_radial_gradient_sse2;
     }
 
 #ifdef QT_HAVE_SSSE3
@@ -7373,6 +7248,11 @@ void qInitDrawhelperAsm()
         qMemRotateFunctions[QImage::Format_RGB16][0] = qt_memrotate90_16_neon;
         qMemRotateFunctions[QImage::Format_RGB16][2] = qt_memrotate270_16_neon;
         qt_memfill32 = qt_memfill32_neon;
+
+        extern const uint * QT_FASTCALL qt_fetch_radial_gradient_neon(uint *buffer, const Operator *op, const QSpanData *data,
+                                                                      int y, int x, int length);
+
+        qt_fetch_radial_gradient = qt_fetch_radial_gradient_neon;
     }
 #endif
 
diff --git a/src/gui/painting/qdrawhelper_neon.cpp b/src/gui/painting/qdrawhelper_neon.cpp
index debca37486..e673dd9861 100644
--- a/src/gui/painting/qdrawhelper_neon.cpp
+++ b/src/gui/painting/qdrawhelper_neon.cpp
@@ -955,6 +955,46 @@ void qt_memrotate270_16_neon(const uchar *srcPixels, int w, int h,
     }
 }
 
+class QSimdNeon
+{
+public:
+    typedef int32x4_t Int32x4;
+    typedef float32x4_t Float32x4;
+
+    union Vect_buffer_i { Int32x4 v; int i[4]; };
+    union Vect_buffer_f { Float32x4 v; float f[4]; };
+
+    static inline Float32x4 v_dup(float x) { return vdupq_n_f32(x); }
+    static inline Int32x4 v_dup(int x) { return vdupq_n_s32(x); }
+    static inline Int32x4 v_dup(uint x) { return vdupq_n_s32(x); }
+
+    static inline Float32x4 v_add(Float32x4 a, Float32x4 b) { return vaddq_f32(a, b); }
+    static inline Int32x4 v_add(Int32x4 a, Int32x4 b) { return vaddq_s32(a, b); }
+
+    static inline Float32x4 v_max(Float32x4 a, Float32x4 b) { return vmaxq_f32(a, b); }
+    static inline Float32x4 v_min(Float32x4 a, Float32x4 b) { return vminq_f32(a, b); }
+    static inline Int32x4 v_min_16(Int32x4 a, Int32x4 b) { return vminq_s32(a, b); }
+
+    static inline Int32x4 v_and(Int32x4 a, Int32x4 b) { return vandq_s32(a, b); }
+
+    static inline Float32x4 v_sub(Float32x4 a, Float32x4 b) { return vsubq_f32(a, b); }
+    static inline Int32x4 v_sub(Int32x4 a, Int32x4 b) { return vsubq_s32(a, b); }
+
+    static inline Float32x4 v_mul(Float32x4 a, Float32x4 b) { return vmulq_f32(a, b); }
+
+    static inline Float32x4 v_sqrt(Float32x4 x) { Float32x4 y = vrsqrteq_f32(x); y = vmulq_f32(y, vrsqrtsq_f32(x, vmulq_f32(y, y))); return vmulq_f32(x, y); }
+
+    static inline Int32x4 v_toInt(Float32x4 x) { return vcvtq_s32_f32(x); }
+
+    static inline Int32x4 v_greaterOrEqual(Float32x4 a, Float32x4 b) { return vcge_f32(a, b); }
+};
+
+const uint * QT_FASTCALL qt_fetch_radial_gradient_neon(uint *buffer, const Operator *op, const QSpanData *data,
+                                                       int y, int x, int length)
+{
+    return qt_fetch_radial_gradient_template<QRadialFetchSimd<QSimdNeon> >(buffer, op, data, y, x, length);
+}
+
 QT_END_NAMESPACE
 
 #endif // QT_HAVE_NEON
diff --git a/src/gui/painting/qdrawhelper_p.h b/src/gui/painting/qdrawhelper_p.h
index a16a9bec51..758b0c88cb 100644
--- a/src/gui/painting/qdrawhelper_p.h
+++ b/src/gui/painting/qdrawhelper_p.h
@@ -63,6 +63,7 @@
 #endif
 #include "private/qrasterdefs_p.h"
 #include <private/qsimd_p.h>
+#include <private/qmath_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -170,6 +171,44 @@ void qBlendTexture(int count, const QSpan *spans, void *userData);
 typedef void (QT_FASTCALL *CompositionFunction)(uint *dest, const uint *src, int length, uint const_alpha);
 typedef void (QT_FASTCALL *CompositionFunctionSolid)(uint *dest, int length, uint color, uint const_alpha);
 
+struct LinearGradientValues
+{
+    qreal dx;
+    qreal dy;
+    qreal l;
+    qreal off;
+};
+
+struct RadialGradientValues
+{
+    qreal dx;
+    qreal dy;
+    qreal dr;
+    qreal sqrfr;
+    qreal a;
+    qreal inv2a;
+    bool extended;
+};
+
+struct Operator;
+typedef uint* (QT_FASTCALL *DestFetchProc)(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length);
+typedef void (QT_FASTCALL *DestStoreProc)(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length);
+typedef const uint* (QT_FASTCALL *SourceFetchProc)(uint *buffer, const Operator *o, const QSpanData *data, int y, int x, int length);
+
+struct Operator
+{
+    QPainter::CompositionMode mode;
+    DestFetchProc dest_fetch;
+    DestStoreProc dest_store;
+    SourceFetchProc src_fetch;
+    CompositionFunctionSolid funcSolid;
+    CompositionFunction func;
+    union {
+        LinearGradientValues linear;
+        RadialGradientValues radial;
+    };
+};
+
 void qInitDrawhelperAsm();
 
 class QRasterPaintEngine;
@@ -196,12 +235,13 @@ struct QRadialGradientData
     struct {
         qreal x;
         qreal y;
+        qreal radius;
     } center;
     struct {
         qreal x;
         qreal y;
+        qreal radius;
     } focal;
-    qreal radius;
 };
 
 struct QConicalGradientData
@@ -224,6 +264,7 @@ struct QGradientData
     };
 
 #define GRADIENT_STOPTABLE_SIZE 1024
+#define GRADIENT_STOPTABLE_SIZE_SHIFT 10
 
     uint* colorTable; //[GRADIENT_STOPTABLE_SIZE];
 
@@ -293,6 +334,218 @@ struct QSpanData
     void adjustSpanMethods();
 };
 
+static inline uint qt_gradient_clamp(const QGradientData *data, int ipos)
+{
+    if (ipos < 0 || ipos >= GRADIENT_STOPTABLE_SIZE) {
+        if (data->spread == QGradient::RepeatSpread) {
+            ipos = ipos % GRADIENT_STOPTABLE_SIZE;
+            ipos = ipos < 0 ? GRADIENT_STOPTABLE_SIZE + ipos : ipos;
+        } else if (data->spread == QGradient::ReflectSpread) {
+            const int limit = GRADIENT_STOPTABLE_SIZE * 2;
+            ipos = ipos % limit;
+            ipos = ipos < 0 ? limit + ipos : ipos;
+            ipos = ipos >= GRADIENT_STOPTABLE_SIZE ? limit - 1 - ipos : ipos;
+        } else {
+            if (ipos < 0)
+                ipos = 0;
+            else if (ipos >= GRADIENT_STOPTABLE_SIZE)
+                ipos = GRADIENT_STOPTABLE_SIZE-1;
+        }
+    }
+
+    Q_ASSERT(ipos >= 0);
+    Q_ASSERT(ipos < GRADIENT_STOPTABLE_SIZE);
+
+    return ipos;
+}
+
+static inline uint qt_gradient_pixel(const QGradientData *data, qreal pos)
+{
+    int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + qreal(0.5));
+    return data->colorTable[qt_gradient_clamp(data, ipos)];
+}
+
+static inline qreal qRadialDeterminant(qreal a, qreal b, qreal c)
+{
+    return (b * b) - (4 * a * c);
+}
+
+template <class RadialFetchFunc>
+const uint * QT_FASTCALL qt_fetch_radial_gradient_template(uint *buffer, const Operator *op, const QSpanData *data,
+                                                           int y, int x, int length)
+{
+    // avoid division by zero
+    if (qFuzzyIsNull(op->radial.a)) {
+        extern void (*qt_memfill32)(quint32 *dest, quint32 value, int count);
+        qt_memfill32(buffer, 0, length);
+        return buffer;
+    }
+
+    const uint *b = buffer;
+    qreal rx = data->m21 * (y + qreal(0.5))
+               + data->dx + data->m11 * (x + qreal(0.5));
+    qreal ry = data->m22 * (y + qreal(0.5))
+               + data->dy + data->m12 * (x + qreal(0.5));
+    bool affine = !data->m13 && !data->m23;
+
+    uint *end = buffer + length;
+    if (affine) {
+        rx -= data->gradient.radial.focal.x;
+        ry -= data->gradient.radial.focal.y;
+
+        qreal inv_a = 1 / qreal(2 * op->radial.a);
+
+        const qreal delta_rx = data->m11;
+        const qreal delta_ry = data->m12;
+
+        qreal b = 2*(op->radial.dr*data->gradient.radial.focal.radius + rx * op->radial.dx + ry * op->radial.dy);
+        qreal delta_b = 2*(delta_rx * op->radial.dx + delta_ry * op->radial.dy);
+        const qreal b_delta_b = 2 * b * delta_b;
+        const qreal delta_b_delta_b = 2 * delta_b * delta_b;
+
+        const qreal bb = b * b;
+        const qreal delta_bb = delta_b * delta_b;
+
+        b *= inv_a;
+        delta_b *= inv_a;
+
+        const qreal rxrxryry = rx * rx + ry * ry;
+        const qreal delta_rxrxryry = delta_rx * delta_rx + delta_ry * delta_ry;
+        const qreal rx_plus_ry = 2*(rx * delta_rx + ry * delta_ry);
+        const qreal delta_rx_plus_ry = 2 * delta_rxrxryry;
+
+        inv_a *= inv_a;
+
+        qreal det = (bb - 4 * op->radial.a * (op->radial.sqrfr - rxrxryry)) * inv_a;
+        qreal delta_det = (b_delta_b + delta_bb + 4 * op->radial.a * (rx_plus_ry + delta_rxrxryry)) * inv_a;
+        const qreal delta_delta_det = (delta_b_delta_b + 4 * op->radial.a * delta_rx_plus_ry) * inv_a;
+
+        RadialFetchFunc::fetch(buffer, end, op, data, det, delta_det, delta_delta_det, b, delta_b);
+    } else {
+        qreal rw = data->m23 * (y + qreal(0.5))
+                   + data->m33 + data->m13 * (x + qreal(0.5));
+
+        while (buffer < end) {
+            if (rw == 0) {
+                *buffer = 0;
+            } else {
+                qreal invRw = 1 / rw;
+                qreal gx = rx * invRw - data->gradient.radial.focal.x;
+                qreal gy = ry * invRw - data->gradient.radial.focal.y;
+                qreal b  = 2*(op->radial.dr*data->gradient.radial.focal.radius + gx*op->radial.dx + gy*op->radial.dy);
+                qreal det = qRadialDeterminant(op->radial.a, b, op->radial.sqrfr - (gx*gx + gy*gy));
+
+                quint32 result = 0;
+                if (det >= 0) {
+                    qreal detSqrt = qSqrt(det);
+
+                    qreal s0 = (-b - detSqrt) * op->radial.inv2a;
+                    qreal s1 = (-b + detSqrt) * op->radial.inv2a;
+
+                    qreal s = qMax(s0, s1);
+
+                    if (data->gradient.radial.focal.radius + op->radial.dr * s >= 0)
+                        result = qt_gradient_pixel(&data->gradient, s);
+                }
+
+                *buffer = result;
+            }
+
+            rx += data->m11;
+            ry += data->m12;
+            rw += data->m13;
+
+            ++buffer;
+        }
+    }
+
+    return b;
+}
+
+template <class Simd>
+class QRadialFetchSimd
+{
+public:
+    static void fetch(uint *buffer, uint *end, const Operator *op, const QSpanData *data, qreal det,
+                      qreal delta_det, qreal delta_delta_det, qreal b, qreal delta_b)
+    {
+        typename Simd::Vect_buffer_f det_vec;
+        typename Simd::Vect_buffer_f delta_det4_vec;
+        typename Simd::Vect_buffer_f b_vec;
+
+        for (int i = 0; i < 4; ++i) {
+            det_vec.f[i] = det;
+            delta_det4_vec.f[i] = 4 * delta_det;
+            b_vec.f[i] = b;
+
+            det += delta_det;
+            delta_det += delta_delta_det;
+            b += delta_b;
+        }
+
+        const typename Simd::Float32x4 v_delta_delta_det16 = Simd::v_dup(16 * delta_delta_det);
+        const typename Simd::Float32x4 v_delta_delta_det6 = Simd::v_dup(6 * delta_delta_det);
+        const typename Simd::Float32x4 v_delta_b4 = Simd::v_dup(4 * delta_b);
+
+        const typename Simd::Float32x4 v_r0 = Simd::v_dup(data->gradient.radial.focal.radius);
+        const typename Simd::Float32x4 v_dr = Simd::v_dup(op->radial.dr);
+
+        const typename Simd::Float32x4 v_min = Simd::v_dup(0.0f);
+        const typename Simd::Float32x4 v_max = Simd::v_dup(float(GRADIENT_STOPTABLE_SIZE-1));
+        const typename Simd::Float32x4 v_half = Simd::v_dup(0.5f);
+
+        const typename Simd::Int32x4 v_repeat_mask = Simd::v_dup(~(uint(0xffffff) << GRADIENT_STOPTABLE_SIZE_SHIFT));
+        const typename Simd::Int32x4 v_reflect_mask = Simd::v_dup(~(uint(0xffffff) << (GRADIENT_STOPTABLE_SIZE_SHIFT+1)));
+
+        const typename Simd::Int32x4 v_reflect_limit = Simd::v_dup(2 * GRADIENT_STOPTABLE_SIZE - 1);
+
+        const int extended_mask = op->radial.extended ? 0x0 : ~0x0;
+
+#define FETCH_RADIAL_LOOP_PROLOGUE \
+        while (buffer < end) { \
+            typename Simd::Vect_buffer_i v_buffer_mask; \
+            v_buffer_mask.v = Simd::v_greaterOrEqual(det_vec.v, v_min); \
+            const typename Simd::Float32x4 v_index_local = Simd::v_sub(Simd::v_sqrt(Simd::v_max(v_min, det_vec.v)), b_vec.v); \
+            const typename Simd::Float32x4 v_index = Simd::v_add(Simd::v_mul(v_index_local, v_max), v_half); \
+            v_buffer_mask.v = Simd::v_and(v_buffer_mask.v, Simd::v_greaterOrEqual(Simd::v_add(v_r0, Simd::v_mul(v_dr, v_index_local)), v_min)); \
+            typename Simd::Vect_buffer_i index_vec;
+#define FETCH_RADIAL_LOOP_CLAMP_REPEAT \
+            index_vec.v = Simd::v_and(v_repeat_mask, Simd::v_toInt(v_index));
+#define FETCH_RADIAL_LOOP_CLAMP_REFLECT \
+            const typename Simd::Int32x4 v_index_i = Simd::v_and(v_reflect_mask, Simd::v_toInt(v_index)); \
+            const typename Simd::Int32x4 v_index_i_inv = Simd::v_sub(v_reflect_limit, v_index_i); \
+            index_vec.v = Simd::v_min_16(v_index_i, v_index_i_inv);
+#define FETCH_RADIAL_LOOP_CLAMP_PAD \
+            index_vec.v = Simd::v_toInt(Simd::v_min(v_max, Simd::v_max(v_min, v_index)));
+#define FETCH_RADIAL_LOOP_EPILOGUE \
+            det_vec.v = Simd::v_add(Simd::v_add(det_vec.v, delta_det4_vec.v), v_delta_delta_det6); \
+            delta_det4_vec.v = Simd::v_add(delta_det4_vec.v, v_delta_delta_det16); \
+            b_vec.v = Simd::v_add(b_vec.v, v_delta_b4); \
+            for (int i = 0; i < 4; ++i) \
+                *buffer++ = (extended_mask | v_buffer_mask.i[i]) & data->gradient.colorTable[index_vec.i[i]]; \
+        }
+
+#define FETCH_RADIAL_LOOP(FETCH_RADIAL_LOOP_CLAMP) \
+        FETCH_RADIAL_LOOP_PROLOGUE \
+        FETCH_RADIAL_LOOP_CLAMP \
+        FETCH_RADIAL_LOOP_EPILOGUE
+
+        switch (data->gradient.spread) {
+        case QGradient::RepeatSpread:
+            FETCH_RADIAL_LOOP(FETCH_RADIAL_LOOP_CLAMP_REPEAT)
+            break;
+        case QGradient::ReflectSpread:
+            FETCH_RADIAL_LOOP(FETCH_RADIAL_LOOP_CLAMP_REFLECT)
+            break;
+        case QGradient::PadSpread:
+            FETCH_RADIAL_LOOP(FETCH_RADIAL_LOOP_CLAMP_PAD)
+            break;
+        default:
+            Q_ASSERT(false);
+        }
+    }
+};
+
 #if defined(Q_CC_RVCT)
 #  pragma push
 #  pragma arm
diff --git a/src/gui/painting/qdrawhelper_sse2.cpp b/src/gui/painting/qdrawhelper_sse2.cpp
index aad6bc9254..75bb619d09 100644
--- a/src/gui/painting/qdrawhelper_sse2.cpp
+++ b/src/gui/painting/qdrawhelper_sse2.cpp
@@ -112,8 +112,6 @@ void qt_blend_rgb32_on_rgb32_sse2(uchar *destPixels, int dbpl,
 
                 // First, align dest to 16 bytes:
                 ALIGNMENT_PROLOGUE_16BYTES(dst, x, w) {
-                    quint32 s = src[x];
-                    s = BYTE_MUL(s, const_alpha);
                     dst[x] = INTERPOLATE_PIXEL_255(src[x], const_alpha, dst[x], one_minus_const_alpha);
                 }
 
@@ -127,8 +125,6 @@ void qt_blend_rgb32_on_rgb32_sse2(uchar *destPixels, int dbpl,
                     }
                 }
                 for (; x<w; ++x) {
-                    quint32 s = src[x];
-                    s = BYTE_MUL(s, const_alpha);
                     dst[x] = INTERPOLATE_PIXEL_255(src[x], const_alpha, dst[x], one_minus_const_alpha);
                 }
                 dst = (quint32 *)(((uchar *) dst) + dbpl);
@@ -491,6 +487,58 @@ void qt_bitmapblit16_sse2(QRasterBuffer *rasterBuffer, int x, int y,
     }
 }
 
+class QSimdSse2
+{
+public:
+    typedef __m128i Int32x4;
+    typedef __m128 Float32x4;
+
+    union Vect_buffer_i { Int32x4 v; int i[4]; };
+    union Vect_buffer_f { Float32x4 v; float f[4]; };
+
+    static inline Float32x4 v_dup(float x) { return _mm_set1_ps(x); }
+    static inline Float32x4 v_dup(double x) { return _mm_set1_ps(x); }
+    static inline Int32x4 v_dup(int x) { return _mm_set1_epi32(x); }
+    static inline Int32x4 v_dup(uint x) { return _mm_set1_epi32(x); }
+
+    static inline Float32x4 v_add(Float32x4 a, Float32x4 b) { return _mm_add_ps(a, b); }
+    static inline Int32x4 v_add(Int32x4 a, Int32x4 b) { return _mm_add_epi32(a, b); }
+
+    static inline Float32x4 v_max(Float32x4 a, Float32x4 b) { return _mm_max_ps(a, b); }
+    static inline Float32x4 v_min(Float32x4 a, Float32x4 b) { return _mm_min_ps(a, b); }
+    static inline Int32x4 v_min_16(Int32x4 a, Int32x4 b) { return _mm_min_epi16(a, b); }
+
+    static inline Int32x4 v_and(Int32x4 a, Int32x4 b) { return _mm_and_si128(a, b); }
+
+    static inline Float32x4 v_sub(Float32x4 a, Float32x4 b) { return _mm_sub_ps(a, b); }
+    static inline Int32x4 v_sub(Int32x4 a, Int32x4 b) { return _mm_sub_epi32(a, b); }
+
+    static inline Float32x4 v_mul(Float32x4 a, Float32x4 b) { return _mm_mul_ps(a, b); }
+
+    static inline Float32x4 v_sqrt(Float32x4 x) { return _mm_sqrt_ps(x); }
+
+    static inline Int32x4 v_toInt(Float32x4 x) { return _mm_cvttps_epi32(x); }
+
+    // pre-VS 2008 doesn't have cast intrinsics, whereas 2008 and later requires it
+#if defined(Q_CC_MSVC) && _MSC_VER < 1500
+    static inline Int32x4 v_greaterOrEqual(Float32x4 a, Float32x4 b)
+    {
+        union Convert { Int32x4 vi; Float32x4 vf; } convert;
+        convert.vf = _mm_cmpgt_ps(a, b);
+        return convert.vi;
+    }
+#else
+    static inline Int32x4 v_greaterOrEqual(Float32x4 a, Float32x4 b) { return _mm_castps_si128(_mm_cmpgt_ps(a, b)); }
+#endif
+};
+
+const uint * QT_FASTCALL qt_fetch_radial_gradient_sse2(uint *buffer, const Operator *op, const QSpanData *data,
+                                                       int y, int x, int length)
+{
+    return qt_fetch_radial_gradient_template<QRadialFetchSimd<QSimdSse2> >(buffer, op, data, y, x, length);
+}
+
+
 QT_END_NAMESPACE
 
 #endif // QT_HAVE_SSE2
diff --git a/src/gui/painting/qpaintbuffer.cpp b/src/gui/painting/qpaintbuffer.cpp
index 7870defd22..6f6cd6f66b 100644
--- a/src/gui/painting/qpaintbuffer.cpp
+++ b/src/gui/painting/qpaintbuffer.cpp
@@ -535,16 +535,6 @@ QString QPaintBuffer::commandDescription(int command) const
         QTextItemInt &ti = (*tiCopy)();
         QString text(ti.text());
 
-        QFont font(ti.font());
-        font.setUnderline(false);
-        font.setStrikeOut(false);
-        font.setOverline(false);
-
-        const QTextItemInt &si = static_cast<const QTextItemInt &>(ti);
-        qreal justificationWidth = 0;
-        if (si.justified)
-            justificationWidth = si.width.toReal();
-
         debug << "Cmd_DrawTextItem:" << pos << " " << text;
         break; }
     case QPaintBufferPrivate::Cmd_SystemStateChanged: {
@@ -1778,12 +1768,12 @@ void QPainterReplayer::process(const QPaintBufferCommand &cmd)
             rawFontD->fontEngine = fontD->engineForScript(QUnicodeTables::Common);
             rawFontD->fontEngine->ref.ref();
 
-            QGlyphs glyphs;
-            glyphs.setFont(rawFont);
+            QGlyphRun glyphs;
+            glyphs.setRawFont(rawFont);
             glyphs.setGlyphIndexes(glyphIndexes);
             glyphs.setPositions(positions);
 
-            painter->drawGlyphs(QPointF(), glyphs);
+            painter->drawGlyphRun(QPointF(), glyphs);
             break;
     }
 #endif
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index 9c86172753..8fc2dbab1a 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -4814,6 +4814,84 @@ void QGradientCache::generateGradientColorTable(const QGradient& gradient, uint
 
     bool colorInterpolation = (gradient.interpolationMode() == QGradient::ColorInterpolation);
 
+    if (stopCount == 2) {
+        uint first_color = ARGB_COMBINE_ALPHA(stops[0].second.rgba(), opacity);
+        uint second_color = ARGB_COMBINE_ALPHA(stops[1].second.rgba(), opacity);
+
+        qreal first_stop = stops[0].first;
+        qreal second_stop = stops[1].first;
+
+        if (second_stop < first_stop) {
+            qSwap(first_color, second_color);
+            qSwap(first_stop, second_stop);
+        }
+
+        if (colorInterpolation) {
+            first_color = PREMUL(first_color);
+            second_color = PREMUL(second_color);
+        }
+
+        int first_index = qRound(first_stop * (GRADIENT_STOPTABLE_SIZE-1));
+        int second_index = qRound(second_stop * (GRADIENT_STOPTABLE_SIZE-1));
+
+        uint red_first = qRed(first_color) << 16;
+        uint green_first = qGreen(first_color) << 16;
+        uint blue_first = qBlue(first_color) << 16;
+        uint alpha_first = qAlpha(first_color) << 16;
+
+        uint red_second = qRed(second_color) << 16;
+        uint green_second = qGreen(second_color) << 16;
+        uint blue_second = qBlue(second_color) << 16;
+        uint alpha_second = qAlpha(second_color) << 16;
+
+        int i = 0;
+        for (; i <= qMin(GRADIENT_STOPTABLE_SIZE, first_index); ++i) {
+            if (colorInterpolation)
+                colorTable[i] = first_color;
+            else
+                colorTable[i] = PREMUL(first_color);
+        }
+
+        if (i < second_index) {
+            qreal reciprocal = qreal(1) / (second_index - first_index);
+
+            int red_delta = qRound(int(red_second - red_first) * reciprocal);
+            int green_delta = qRound(int(green_second - green_first) * reciprocal);
+            int blue_delta = qRound(int(blue_second - blue_first) * reciprocal);
+            int alpha_delta = qRound(int(alpha_second - alpha_first) * reciprocal);
+
+            // rounding
+            red_first += 1 << 15;
+            green_first += 1 << 15;
+            blue_first += 1 << 15;
+            alpha_first += 1 << 15;
+
+            for (; i < qMin(GRADIENT_STOPTABLE_SIZE, second_index); ++i) {
+                red_first += red_delta;
+                green_first += green_delta;
+                blue_first += blue_delta;
+                alpha_first += alpha_delta;
+
+                const uint color = ((alpha_first << 8) & 0xff000000) | (red_first & 0xff0000)
+                                 | ((green_first >> 8) & 0xff00) | (blue_first >> 16);
+
+                if (colorInterpolation)
+                    colorTable[i] = color;
+                else
+                    colorTable[i] = PREMUL(color);
+            }
+        }
+
+        for (; i < GRADIENT_STOPTABLE_SIZE; ++i) {
+            if (colorInterpolation)
+                colorTable[i] = second_color;
+            else
+                colorTable[i] = PREMUL(second_color);
+        }
+
+        return;
+    }
+
     uint current_color = ARGB_COMBINE_ALPHA(stops[0].second.rgba(), opacity);
     if (stopCount == 1) {
         current_color = PREMUL(current_color);
@@ -4982,10 +5060,11 @@ void QSpanData::setup(const QBrush &brush, int alpha, QPainter::CompositionMode
             QPointF center = g->center();
             radialData.center.x = center.x();
             radialData.center.y = center.y();
+            radialData.center.radius = g->centerRadius();
             QPointF focal = g->focalPoint();
             radialData.focal.x = focal.x();
             radialData.focal.y = focal.y();
-            radialData.radius = g->radius();
+            radialData.focal.radius = g->focalRadius();
         }
         break;
 
diff --git a/src/gui/painting/qpaintengineex.cpp b/src/gui/painting/qpaintengineex.cpp
index 509fb77d25..7f601eb755 100644
--- a/src/gui/painting/qpaintengineex.cpp
+++ b/src/gui/painting/qpaintengineex.cpp
@@ -1012,4 +1012,50 @@ void QPaintEngineEx::updateState(const QPaintEngineState &)
     // do nothing...
 }
 
+Q_GUI_EXPORT QPainterPath qt_painterPathFromVectorPath(const QVectorPath &path)
+{
+    const qreal *points = path.points();
+    const QPainterPath::ElementType *types = path.elements();
+
+    QPainterPath p;
+    if (types) {
+        int id = 0;
+        for (int i=0; i<path.elementCount(); ++i) {
+            switch(types[i]) {
+            case QPainterPath::MoveToElement:
+                p.moveTo(QPointF(points[id], points[id+1]));
+                id+=2;
+                break;
+            case QPainterPath::LineToElement:
+                p.lineTo(QPointF(points[id], points[id+1]));
+                id+=2;
+                break;
+            case QPainterPath::CurveToElement: {
+                QPointF p1(points[id], points[id+1]);
+                QPointF p2(points[id+2], points[id+3]);
+                QPointF p3(points[id+4], points[id+5]);
+                p.cubicTo(p1, p2, p3);
+                id+=6;
+                break;
+            }
+            case QPainterPath::CurveToDataElement:
+                ;
+                break;
+            }
+        }
+    } else {
+        p.moveTo(QPointF(points[0], points[1]));
+        int id = 2;
+        for (int i=1; i<path.elementCount(); ++i) {
+            p.lineTo(QPointF(points[id], points[id+1]));
+            id+=2;
+        }
+    }
+    if (path.hints() & QVectorPath::WindingFill)
+        p.setFillRule(Qt::WindingFill);
+
+    return p;
+}
+
+
 QT_END_NAMESPACE
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index f974186f58..64e84e5310 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -59,7 +59,7 @@
 #include "qthread.h"
 #include "qvarlengtharray.h"
 #include "qstatictext.h"
-#include "qglyphs.h"
+#include "qglyphrun.h"
 
 #include <private/qfontengine_p.h>
 #include <private/qpaintengine_p.h>
@@ -69,7 +69,7 @@
 #include <private/qpaintengine_raster_p.h>
 #include <private/qmath_p.h>
 #include <private/qstatictext_p.h>
-#include <private/qglyphs_p.h>
+#include <private/qglyphrun_p.h>
 #include <private/qhexstring_p.h>
 #include <private/qguiapplication_p.h>
 #include <private/qrawfont_p.h>
@@ -477,8 +477,12 @@ void QPainterPrivate::draw_helper(const QPainterPath &originalPath, DrawOperatio
 
     q->save();
     state->matrix = QTransform();
-    state->dirtyFlags |= QPaintEngine::DirtyTransform;
-    updateState(state);
+    if (extended) {
+        extended->transformChanged();
+    } else {
+        state->dirtyFlags |= QPaintEngine::DirtyTransform;
+        updateState(state);
+    }
     engine->drawImage(absPathRect,
                  image,
                  QRectF(0, 0, absPathRect.width(), absPathRect.height()),
@@ -661,11 +665,14 @@ void QPainterPrivate::updateInvMatrix()
     invMatrix = state->matrix.inverted();
 }
 
+extern bool qt_isExtendedRadialGradient(const QBrush &brush);
+
 void QPainterPrivate::updateEmulationSpecifier(QPainterState *s)
 {
     bool alpha = false;
     bool linearGradient = false;
     bool radialGradient = false;
+    bool extendedRadialGradient = false;
     bool conicalGradient = false;
     bool patternBrush = false;
     bool xform = false;
@@ -697,6 +704,7 @@ void QPainterPrivate::updateEmulationSpecifier(QPainterState *s)
                            (brushStyle == Qt::LinearGradientPattern));
         radialGradient = ((penBrushStyle == Qt::RadialGradientPattern) ||
                            (brushStyle == Qt::RadialGradientPattern));
+        extendedRadialGradient = radialGradient && (qt_isExtendedRadialGradient(penBrush) || qt_isExtendedRadialGradient(s->brush));
         conicalGradient = ((penBrushStyle == Qt::ConicalGradientPattern) ||
                             (brushStyle == Qt::ConicalGradientPattern));
         patternBrush = (((penBrushStyle > Qt::SolidPattern
@@ -780,7 +788,7 @@ void QPainterPrivate::updateEmulationSpecifier(QPainterState *s)
         s->emulationSpecifier &= ~QPaintEngine::LinearGradientFill;
 
     // Radial gradient emulation
-    if (radialGradient && !engine->hasFeature(QPaintEngine::RadialGradientFill))
+    if (extendedRadialGradient || (radialGradient && !engine->hasFeature(QPaintEngine::RadialGradientFill)))
         s->emulationSpecifier |= QPaintEngine::RadialGradientFill;
     else
         s->emulationSpecifier &= ~QPaintEngine::RadialGradientFill;
@@ -5664,19 +5672,19 @@ void QPainter::drawImage(const QRectF &targetRect, const QImage &image, const QR
 
     \since 4.8
 
-    \sa QGlyphs::setFont(), QGlyphs::setPositions(), QGlyphs::setGlyphIndexes()
+    \sa QGlyphRun::setRawFont(), QGlyphRun::setPositions(), QGlyphRun::setGlyphIndexes()
 */
 #if !defined(QT_NO_RAWFONT)
-void QPainter::drawGlyphs(const QPointF &position, const QGlyphs &glyphs)
+void QPainter::drawGlyphRun(const QPointF &position, const QGlyphRun &glyphRun)
 {
     Q_D(QPainter);
 
-    QRawFont font = glyphs.font();
+    QRawFont font = glyphRun.rawFont();
     if (!font.isValid())
         return;
 
-    QVector<quint32> glyphIndexes = glyphs.glyphIndexes();
-    QVector<QPointF> glyphPositions = glyphs.positions();
+    QVector<quint32> glyphIndexes = glyphRun.glyphIndexes();
+    QVector<QPointF> glyphPositions = glyphRun.positions();
 
     int count = qMin(glyphIndexes.size(), glyphPositions.size());
     QVarLengthArray<QFixedPoint, 128> fixedPointPositions(count);
@@ -5685,6 +5693,13 @@ void QPainter::drawGlyphs(const QPointF &position, const QGlyphs &glyphs)
             d->extended != 0
             ? qt_paintengine_supports_transformations(d->extended->type())
             : qt_paintengine_supports_transformations(d->engine->type());
+
+    // If the matrix is not affine, the paint engine will fall back to
+    // drawing the glyphs as paths, which in turn means we should not
+    // preprocess the glyph positions
+    if (!d->state->matrix.isAffine())
+        paintEngineSupportsTransformations = true;
+
     for (int i=0; i<count; ++i) {
         QPointF processedPosition = position + glyphPositions.at(i);
         if (!paintEngineSupportsTransformations)
@@ -5692,8 +5707,8 @@ void QPainter::drawGlyphs(const QPointF &position, const QGlyphs &glyphs)
         fixedPointPositions[i] = QFixedPoint::fromPointF(processedPosition);
     }
 
-    d->drawGlyphs(glyphIndexes.data(), fixedPointPositions.data(), count, font, glyphs.overline(),
-                  glyphs.underline(), glyphs.strikeOut());
+    d->drawGlyphs(glyphIndexes.data(), fixedPointPositions.data(), count, font, glyphRun.overline(),
+                  glyphRun.underline(), glyphRun.strikeOut());
 }
 
 void QPainterPrivate::drawGlyphs(quint32 *glyphArray, QFixedPoint *positions, int glyphCount,
@@ -5728,7 +5743,7 @@ void QPainterPrivate::drawGlyphs(quint32 *glyphArray, QFixedPoint *positions, in
 
     QFixed width = rightMost - leftMost;
 
-    if (extended != 0) {
+    if (extended != 0 && state->matrix.isAffine()) {
         QStaticTextItem staticTextItem;
         staticTextItem.color = state->pen.color();
         staticTextItem.font = state->font;
diff --git a/src/gui/painting/qpainter.h b/src/gui/painting/qpainter.h
index 0be3dfcbb3..7420801998 100644
--- a/src/gui/painting/qpainter.h
+++ b/src/gui/painting/qpainter.h
@@ -78,7 +78,7 @@ class QTextItem;
 class QMatrix;
 class QTransform;
 class QStaticText;
-class QGlyphs;
+class QGlyphRun;
 
 class QPainterPrivateDeleter;
 
@@ -399,7 +399,7 @@ public:
     Qt::LayoutDirection layoutDirection() const;
 
 #if !defined(QT_NO_RAWFONT)
-    void drawGlyphs(const QPointF &position, const QGlyphs &glyphs);
+    void drawGlyphRun(const QPointF &position, const QGlyphRun &glyphRun);
 #endif
 
     void drawStaticText(const QPointF &topLeftPosition, const QStaticText &staticText);
@@ -480,6 +480,7 @@ private:
     friend class QPaintEngine;
     friend class QPaintEngineExPrivate;
     friend class QOpenGLPaintEngine;
+    friend class QVGPaintEngine;
     friend class QX11PaintEngine;
     friend class QX11PaintEnginePrivate;
     friend class QWin32PaintEngine;
diff --git a/src/gui/painting/qpainterpath.cpp b/src/gui/painting/qpainterpath.cpp
index 27aed3226f..9fbac13f47 100644
--- a/src/gui/painting/qpainterpath.cpp
+++ b/src/gui/painting/qpainterpath.cpp
@@ -1126,6 +1126,7 @@ void QPainterPath::addText(const QPointF &point, const QFont &f, const QString &
     QTextEngine *eng = layout.engine();
     layout.beginLayout();
     QTextLine line = layout.createLine();
+    Q_UNUSED(line);
     layout.endLayout();
     const QScriptLine &sl = eng->lines[0];
     if (!sl.length || !eng->layoutData)
diff --git a/src/gui/painting/qprintengine_pdf.cpp b/src/gui/painting/qprintengine_pdf.cpp
index b7f51606da..353869f3a4 100644
--- a/src/gui/painting/qprintengine_pdf.cpp
+++ b/src/gui/painting/qprintengine_pdf.cpp
@@ -534,7 +534,10 @@ int QPdfEnginePrivate::addImage(const QImage &img, bool *bitmap, qint64 serial_n
 
     QImage image = img;
     QImage::Format format = image.format();
-    if (image.depth() == 1 && *bitmap && img.colorTable().size() == 0) {
+    if (image.depth() == 1 && *bitmap && img.colorTable().size() == 2
+        && img.colorTable().at(0) == QColor(Qt::black).rgba()
+        && img.colorTable().at(1) == QColor(Qt::white).rgba())
+    {
         if (format == QImage::Format_MonoLSB)
             image = image.convertToFormat(QImage::Format_Mono);
         format = QImage::Format_Mono;
diff --git a/src/gui/painting/qstroker.cpp b/src/gui/painting/qstroker.cpp
index fca46b45f7..dd723edc45 100644
--- a/src/gui/painting/qstroker.cpp
+++ b/src/gui/painting/qstroker.cpp
@@ -552,6 +552,7 @@ void QStroker::joinPoints(qfixed focal_x, qfixed focal_y, const QLineF &nextLine
 
 //             // line to the beginning of the arc segment, (should not be needed).
 //             emitLineTo(qt_real_to_fixed(curve_start.x()), qt_real_to_fixed(curve_start.y()));
+            Q_UNUSED(curve_start);
 
             for (int i=0; i<point_count; i+=3) {
                 emitCubicTo(qt_real_to_fixed(curves[i].x()),
diff --git a/src/gui/text/qfontengine_ft.cpp b/src/gui/text/qfontengine_ft.cpp
index 58bcca87b7..4dae2a3784 100644
--- a/src/gui/text/qfontengine_ft.cpp
+++ b/src/gui/text/qfontengine_ft.cpp
@@ -803,106 +803,6 @@ int QFontEngineFT::loadFlags(QGlyphSet *set, GlyphFormat format, int flags,
     return load_flags;
 }
 
-QFontEngineFT::Glyph *QFontEngineFT::loadGlyphMetrics(QGlyphSet *set, uint glyph, GlyphFormat format) const
-{
-    Glyph *g = set->getGlyph(glyph);
-    if (g && g->format == format)
-        return g;
-
-    bool hsubpixel = false;
-    int vfactor = 1;
-    int load_flags = loadFlags(set, format, 0, hsubpixel, vfactor);
-
-    // apply our matrix to this, but note that the metrics will not be affected by this.
-    FT_Face face = lockFace();
-    FT_Matrix matrix = this->matrix;
-    FT_Matrix_Multiply(&set->transformationMatrix, &matrix);
-    FT_Set_Transform(face, &matrix, 0);
-    freetype->matrix = matrix;
-
-    bool transform = matrix.xx != 0x10000 || matrix.yy != 0x10000 || matrix.xy != 0 || matrix.yx != 0;
-    if (transform)
-        load_flags |= FT_LOAD_NO_BITMAP;
-
-    FT_Error err = FT_Load_Glyph(face, glyph, load_flags);
-    if (err && (load_flags & FT_LOAD_NO_BITMAP)) {
-        load_flags &= ~FT_LOAD_NO_BITMAP;
-        err = FT_Load_Glyph(face, glyph, load_flags);
-    }
-    if (err == FT_Err_Too_Few_Arguments) {
-        // this is an error in the bytecode interpreter, just try to run without it
-        load_flags |= FT_LOAD_FORCE_AUTOHINT;
-        err = FT_Load_Glyph(face, glyph, load_flags);
-    }
-    if (err != FT_Err_Ok)
-        qWarning("load glyph failed err=%x face=%p, glyph=%d", err, face, glyph);
-
-    unlockFace();
-    if (set->outline_drawing)
-        return 0;
-
-    if (!g) {
-        g = new Glyph;
-        g->uploadedToServer = false;
-        g->data = 0;
-    }
-
-    FT_GlyphSlot slot = face->glyph;
-    if (embolden) Q_FT_GLYPHSLOT_EMBOLDEN(slot);
-    int left  = slot->metrics.horiBearingX;
-    int right = slot->metrics.horiBearingX + slot->metrics.width;
-    int top    = slot->metrics.horiBearingY;
-    int bottom = slot->metrics.horiBearingY - slot->metrics.height;
-    if (transform && slot->format != FT_GLYPH_FORMAT_BITMAP) { // freetype doesn't apply the transformation on the metrics
-        int l, r, t, b;
-        FT_Vector vector;
-        vector.x = left;
-        vector.y = top;
-        FT_Vector_Transform(&vector, &matrix);
-        l = r = vector.x;
-        t = b = vector.y;
-        vector.x = right;
-        vector.y = top;
-        FT_Vector_Transform(&vector, &matrix);
-        if (l > vector.x) l = vector.x;
-        if (r < vector.x) r = vector.x;
-        if (t < vector.y) t = vector.y;
-        if (b > vector.y) b = vector.y;
-        vector.x = right;
-        vector.y = bottom;
-        FT_Vector_Transform(&vector, &matrix);
-        if (l > vector.x) l = vector.x;
-        if (r < vector.x) r = vector.x;
-        if (t < vector.y) t = vector.y;
-        if (b > vector.y) b = vector.y;
-        vector.x = left;
-        vector.y = bottom;
-        FT_Vector_Transform(&vector, &matrix);
-        if (l > vector.x) l = vector.x;
-        if (r < vector.x) r = vector.x;
-        if (t < vector.y) t = vector.y;
-        if (b > vector.y) b = vector.y;
-        left = l;
-        right = r;
-        top = t;
-        bottom = b;
-    }
-    left = FLOOR(left);
-    right = CEIL(right);
-    bottom = FLOOR(bottom);
-    top = CEIL(top);
-
-    g->linearAdvance = face->glyph->linearHoriAdvance >> 10;
-    g->width = TRUNC(right-left);
-    g->height = TRUNC(top-bottom);
-    g->x = TRUNC(left);
-    g->y = TRUNC(top);
-    g->advance = TRUNC(ROUND(face->glyph->advance.x));
-    g->format = Format_None;
-
-    return g;
-}
-
 QFontEngineFT::Glyph *QFontEngineFT::loadGlyph(QGlyphSet *set, uint glyph,
                                                QFixed subPixelPosition,
                                                GlyphFormat format,
@@ -1697,7 +1597,7 @@ void QFontEngineFT::recalcAdvances(QGlyphLayout *glyphs, QTextEngine::ShaperFlag
     FT_Face face = 0;
     bool design = (default_hint_style == HintNone ||
                    default_hint_style == HintLight ||
-                   (flags & HB_ShaperFlag_UseDesignMetrics));
+                   (flags & HB_ShaperFlag_UseDesignMetrics)) && FT_IS_SCALABLE(freetype->face);
     for (int i = 0; i < glyphs->numGlyphs; i++) {
         Glyph *g = defaultGlyphSet.getGlyph(glyphs->glyphs[i]);
         if (g) {
diff --git a/src/gui/text/qfontengine_ft_p.h b/src/gui/text/qfontengine_ft_p.h
index 2c335f3cd3..41064715b1 100644
--- a/src/gui/text/qfontengine_ft_p.h
+++ b/src/gui/text/qfontengine_ft_p.h
@@ -343,7 +343,6 @@ protected:
 private:
     friend class QFontEngineFTRawFont;
 
-    QFontEngineFT::Glyph *loadGlyphMetrics(QGlyphSet *set, uint glyph, GlyphFormat format) const;
     int loadFlags(QGlyphSet *set, GlyphFormat format, int flags, bool &hsubpixel, int &vfactor) const;
 
     GlyphFormat defaultFormat;
diff --git a/src/gui/text/qglyphs.cpp b/src/gui/text/qglyphrun.cpp
index cfea6ece93..ea527886cd 100644
--- a/src/gui/text/qglyphs.cpp
+++ b/src/gui/text/qglyphrun.cpp
@@ -43,14 +43,14 @@
 
 #if !defined(QT_NO_RAWFONT)
 
-#include "qglyphs.h"
-#include "qglyphs_p.h"
+#include "qglyphrun.h"
+#include "qglyphrun_p.h"
 
 QT_BEGIN_NAMESPACE
 
 /*!
-    \class QGlyphs
-    \brief The QGlyphs class provides direct access to the internal glyphs in a font.
+    \class QGlyphRun
+    \brief The QGlyphRun class provides direct access to the internal glyphs in a font.
     \since 4.8
 
     \ingroup text
@@ -67,42 +67,43 @@ QT_BEGIN_NAMESPACE
     Under certain circumstances, it can be useful as an application developer to have more low-level
     control over which glyphs in a specific font are drawn to the screen. This could for instance
     be the case in applications that use an external font engine and text shaper together with Qt.
-    QGlyphs provides an interface to the raw data needed to get text on the screen. It
+    QGlyphRun provides an interface to the raw data needed to get text on the screen. It
     contains a list of glyph indexes, a position for each glyph and a font.
 
     It is the user's responsibility to ensure that the selected font actually contains the
     provided glyph indexes.
 
-    QTextLayout::glyphs() or QTextFragment::glyphs() can be used to convert unicode encoded text
-    into a list of QGlyphs objects, and QPainter::drawGlyphs() can be used to draw the glyphs.
+    QTextLayout::glyphRuns() or QTextFragment::glyphRuns() can be used to convert unicode encoded
+    text into a list of QGlyphRun objects, and QPainter::drawGlyphRun() can be used to draw the
+    glyphs.
 
     \note Please note that QRawFont is considered local to the thread in which it is constructed.
-    This in turn means that a new QRawFont will have to be created and set on the QGlyphs if it is
-    moved to a different thread. If the QGlyphs contains a reference to a QRawFont from a different
+    This in turn means that a new QRawFont will have to be created and set on the QGlyphRun if it is
+    moved to a different thread. If the QGlyphRun contains a reference to a QRawFont from a different
     thread than the current, it will not be possible to draw the glyphs using a QPainter, as the
     QRawFont is considered invalid and inaccessible in this case.
 */
 
 
 /*!
-    Constructs an empty QGlyphs object.
+    Constructs an empty QGlyphRun object.
 */
-QGlyphs::QGlyphs() : d(new QGlyphsPrivate)
+QGlyphRun::QGlyphRun() : d(new QGlyphRunPrivate)
 {
 }
 
 /*!
-    Constructs a QGlyphs object which is a copy of \a other.
+    Constructs a QGlyphRun object which is a copy of \a other.
 */
-QGlyphs::QGlyphs(const QGlyphs &other)
+QGlyphRun::QGlyphRun(const QGlyphRun &other)
 {
     d = other.d;
 }
 
 /*!
-    Destroys the QGlyphs.
+    Destroys the QGlyphRun.
 */
-QGlyphs::~QGlyphs()
+QGlyphRun::~QGlyphRun()
 {
     // Required for QExplicitlySharedDataPointer
 }
@@ -110,26 +111,26 @@ QGlyphs::~QGlyphs()
 /*!
     \internal
 */
-void QGlyphs::detach()
+void QGlyphRun::detach()
 {
     if (d->ref != 1)
         d.detach();
 }
 
 /*!
-    Assigns \a other to this QGlyphs object.
+    Assigns \a other to this QGlyphRun object.
 */
-QGlyphs &QGlyphs::operator=(const QGlyphs &other)
+QGlyphRun &QGlyphRun::operator=(const QGlyphRun &other)
 {
     d = other.d;
     return *this;
 }
 
 /*!
-    Compares \a other to this QGlyphs object. Returns true if the list of glyph indexes,
+    Compares \a other to this QGlyphRun object. Returns true if the list of glyph indexes,
     the list of positions and the font are all equal, otherwise returns false.
 */
-bool QGlyphs::operator==(const QGlyphs &other) const
+bool QGlyphRun::operator==(const QGlyphRun &other) const
 {
     return ((d == other.d)
             || (d->glyphIndexes == other.d->glyphIndexes
@@ -137,14 +138,14 @@ bool QGlyphs::operator==(const QGlyphs &other) const
                 && d->overline == other.d->overline
                 && d->underline == other.d->underline
                 && d->strikeOut == other.d->strikeOut
-                && d->font == other.d->font));
+                && d->rawFont == other.d->rawFont));
 }
 
 /*!
-    Compares \a other to this QGlyphs object. Returns true if any of the list of glyph
+    Compares \a other to this QGlyphRun object. Returns true if any of the list of glyph
     indexes, the list of positions or the font are different, otherwise returns false.
 */
-bool QGlyphs::operator!=(const QGlyphs &other) const
+bool QGlyphRun::operator!=(const QGlyphRun &other) const
 {
     return !(*this == other);
 }
@@ -152,13 +153,13 @@ bool QGlyphs::operator!=(const QGlyphs &other) const
 /*!
     \internal
 
-    Adds together the lists of glyph indexes and positions in \a other and this QGlyphs
-    object and returns the result. The font in the returned QGlyphs will be the same as in
-    this QGlyphs object.
+    Adds together the lists of glyph indexes and positions in \a other and this QGlyphRun
+    object and returns the result. The font in the returned QGlyphRun will be the same as in
+    this QGlyphRun object.
 */
-QGlyphs QGlyphs::operator+(const QGlyphs &other) const
+QGlyphRun QGlyphRun::operator+(const QGlyphRun &other) const
 {
-    QGlyphs ret(*this);
+    QGlyphRun ret(*this);
     ret += other;
     return ret;
 }
@@ -166,10 +167,10 @@ QGlyphs QGlyphs::operator+(const QGlyphs &other) const
 /*!
     \internal
 
-    Appends the glyph indexes and positions in \a other to this QGlyphs object and returns
+    Appends the glyph indexes and positions in \a other to this QGlyphRun object and returns
     a reference to the current object.
 */
-QGlyphs &QGlyphs::operator+=(const QGlyphs &other)
+QGlyphRun &QGlyphRun::operator+=(const QGlyphRun &other)
 {
     detach();
 
@@ -180,41 +181,41 @@ QGlyphs &QGlyphs::operator+=(const QGlyphs &other)
 }
 
 /*!
-    Returns the font selected for this QGlyphs object.
+    Returns the font selected for this QGlyphRun object.
 
-    \sa setFont()
+    \sa setRawFont()
 */
-QRawFont QGlyphs::font() const
+QRawFont QGlyphRun::rawFont() const
 {
-    return d->font;
+    return d->rawFont;
 }
 
 /*!
     Sets the font in which to look up the glyph indexes to \a font.
 
-    \sa font(), setGlyphIndexes()
+    \sa rawFont(), setGlyphIndexes()
 */
-void QGlyphs::setFont(const QRawFont &font)
+void QGlyphRun::setRawFont(const QRawFont &rawFont)
 {
     detach();
-    d->font = font;
+    d->rawFont = rawFont;
 }
 
 /*!
-    Returns the glyph indexes for this QGlyphs object.
+    Returns the glyph indexes for this QGlyphRun object.
 
     \sa setGlyphIndexes(), setPositions()
 */
-QVector<quint32> QGlyphs::glyphIndexes() const
+QVector<quint32> QGlyphRun::glyphIndexes() const
 {
     return d->glyphIndexes;
 }
 
 /*!
-    Set the glyph indexes for this QGlyphs object to \a glyphIndexes. The glyph indexes must
+    Set the glyph indexes for this QGlyphRun object to \a glyphIndexes. The glyph indexes must
     be valid for the selected font.
 */
-void QGlyphs::setGlyphIndexes(const QVector<quint32> &glyphIndexes)
+void QGlyphRun::setGlyphIndexes(const QVector<quint32> &glyphIndexes)
 {
     detach();
     d->glyphIndexes = glyphIndexes;
@@ -223,7 +224,7 @@ void QGlyphs::setGlyphIndexes(const QVector<quint32> &glyphIndexes)
 /*!
     Returns the position of the edge of the baseline for each glyph in this set of glyph indexes.
 */
-QVector<QPointF> QGlyphs::positions() const
+QVector<QPointF> QGlyphRun::positions() const
 {
     return d->glyphPositions;
 }
@@ -232,87 +233,87 @@ QVector<QPointF> QGlyphs::positions() const
     Sets the positions of the edge of the baseline for each glyph in this set of glyph indexes to
     \a positions.
 */
-void QGlyphs::setPositions(const QVector<QPointF> &positions)
+void QGlyphRun::setPositions(const QVector<QPointF> &positions)
 {
     detach();
     d->glyphPositions = positions;
 }
 
 /*!
-    Clears all data in the QGlyphs object.
+    Clears all data in the QGlyphRun object.
 */
-void QGlyphs::clear()
+void QGlyphRun::clear()
 {
     detach();
     d->glyphPositions = QVector<QPointF>();
     d->glyphIndexes = QVector<quint32>();
-    d->font = QRawFont();
+    d->rawFont = QRawFont();
     d->strikeOut = false;
     d->overline = false;
     d->underline = false;
 }
 
 /*!
-   Returns true if this QGlyphs should be painted with an overline decoration.
+   Returns true if this QGlyphRun should be painted with an overline decoration.
 
    \sa setOverline()
 */
-bool QGlyphs::overline() const
+bool QGlyphRun::overline() const
 {
     return d->overline;
 }
 
 /*!
-  Indicates that this QGlyphs should be painted with an overline decoration if \a overline is true.
-  Otherwise the QGlyphs should be painted with no overline decoration.
+  Indicates that this QGlyphRun should be painted with an overline decoration if \a overline is true.
+  Otherwise the QGlyphRun should be painted with no overline decoration.
 
   \sa overline()
 */
-void QGlyphs::setOverline(bool overline)
+void QGlyphRun::setOverline(bool overline)
 {
     detach();
     d->overline = overline;
 }
 
 /*!
-   Returns true if this QGlyphs should be painted with an underline decoration.
+   Returns true if this QGlyphRun should be painted with an underline decoration.
 
    \sa setUnderline()
 */
-bool QGlyphs::underline() const
+bool QGlyphRun::underline() const
 {
     return d->underline;
 }
 
 /*!
-  Indicates that this QGlyphs should be painted with an underline decoration if \a underline is
-  true. Otherwise the QGlyphs should be painted with no underline decoration.
+  Indicates that this QGlyphRun should be painted with an underline decoration if \a underline is
+  true. Otherwise the QGlyphRun should be painted with no underline decoration.
 
   \sa underline()
 */
-void QGlyphs::setUnderline(bool underline)
+void QGlyphRun::setUnderline(bool underline)
 {
     detach();
     d->underline = underline;
 }
 
 /*!
-   Returns true if this QGlyphs should be painted with a strike out decoration.
+   Returns true if this QGlyphRun should be painted with a strike out decoration.
 
    \sa setStrikeOut()
 */
-bool QGlyphs::strikeOut() const
+bool QGlyphRun::strikeOut() const
 {
     return d->strikeOut;
 }
 
 /*!
-  Indicates that this QGlyphs should be painted with an strike out decoration if \a strikeOut is
-  true. Otherwise the QGlyphs should be painted with no strike out decoration.
+  Indicates that this QGlyphRun should be painted with an strike out decoration if \a strikeOut is
+  true. Otherwise the QGlyphRun should be painted with no strike out decoration.
 
   \sa strikeOut()
 */
-void QGlyphs::setStrikeOut(bool strikeOut)
+void QGlyphRun::setStrikeOut(bool strikeOut)
 {
     detach();
     d->strikeOut = strikeOut;
diff --git a/src/gui/text/qglyphs.h b/src/gui/text/qglyphrun.h
index 4d7dcaf554..dcc166ea3e 100644
--- a/src/gui/text/qglyphs.h
+++ b/src/gui/text/qglyphrun.h
@@ -39,8 +39,8 @@
 **
 ****************************************************************************/
 
-#ifndef QGLYPHS_H
-#define QGLYPHS_H
+#ifndef QGLYPHRUN_H
+#define QGLYPHRUN_H
 
 #include <QtCore/qsharedpointer.h>
 #include <QtCore/qvector.h>
@@ -55,16 +55,16 @@ QT_BEGIN_NAMESPACE
 
 QT_MODULE(Gui)
 
-class QGlyphsPrivate;
-class Q_GUI_EXPORT QGlyphs
+class QGlyphRunPrivate;
+class Q_GUI_EXPORT QGlyphRun
 {
 public:
-    QGlyphs();
-    QGlyphs(const QGlyphs &other);
-    ~QGlyphs();
+    QGlyphRun();
+    QGlyphRun(const QGlyphRun &other);
+    ~QGlyphRun();
 
-    QRawFont font() const;
-    void setFont(const QRawFont &font);
+    QRawFont rawFont() const;
+    void setRawFont(const QRawFont &rawFont);
 
     QVector<quint32> glyphIndexes() const;
     void setGlyphIndexes(const QVector<quint32> &glyphIndexes);
@@ -74,9 +74,9 @@ public:
 
     void clear();
 
-    QGlyphs &operator=(const QGlyphs &other);
-    bool operator==(const QGlyphs &other) const;
-    bool operator!=(const QGlyphs &other) const;
+    QGlyphRun &operator=(const QGlyphRun &other);
+    bool operator==(const QGlyphRun &other) const;
+    bool operator!=(const QGlyphRun &other) const;
 
     void setOverline(bool overline);
     bool overline() const;
@@ -88,14 +88,14 @@ public:
     bool strikeOut() const;
 
 private:
-    friend class QGlyphsPrivate;
+    friend class QGlyphRunPrivate;
     friend class QTextLine;
 
-    QGlyphs operator+(const QGlyphs &other) const;
-    QGlyphs &operator+=(const QGlyphs &other);
+    QGlyphRun operator+(const QGlyphRun &other) const;
+    QGlyphRun &operator+=(const QGlyphRun &other);
 
     void detach();
-    QExplicitlySharedDataPointer<QGlyphsPrivate> d;
+    QExplicitlySharedDataPointer<QGlyphRunPrivate> d;
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/text/qglyphs_p.h b/src/gui/text/qglyphrun_p.h
index 944f777d4a..4aa01d6bda 100644
--- a/src/gui/text/qglyphs_p.h
+++ b/src/gui/text/qglyphrun_p.h
@@ -39,8 +39,8 @@
 **
 ****************************************************************************/
 
-#ifndef QGLYPHS_P_H
-#define QGLYPHS_P_H
+#ifndef QGLYPHRUN_P_H
+#define QGLYPHRUN_P_H
 
 //
 //  W A R N I N G
@@ -53,7 +53,7 @@
 // We mean it.
 //
 
-#include "qglyphs.h"
+#include "qglyphrun.h"
 #include "qrawfont.h"
 
 #include <qfont.h>
@@ -64,21 +64,21 @@ QT_BEGIN_HEADER
 
 QT_BEGIN_NAMESPACE
 
-class QGlyphsPrivate: public QSharedData
+class QGlyphRunPrivate: public QSharedData
 {
 public:
-    QGlyphsPrivate()
+    QGlyphRunPrivate()
         : overline(false)
         , underline(false)
         , strikeOut(false)
     {
     }
 
-    QGlyphsPrivate(const QGlyphsPrivate &other)
+    QGlyphRunPrivate(const QGlyphRunPrivate &other)
       : QSharedData(other)
       , glyphIndexes(other.glyphIndexes)
       , glyphPositions(other.glyphPositions)
-      , font(other.font)
+      , rawFont(other.rawFont)
       , overline(other.overline)
       , underline(other.underline)
       , strikeOut(other.strikeOut)
@@ -87,7 +87,7 @@ public:
 
     QVector<quint32> glyphIndexes;
     QVector<QPointF> glyphPositions;
-    QRawFont font;
+    QRawFont rawFont;
 
     uint overline  : 1;
     uint underline : 1;
diff --git a/src/gui/text/qrawfont.cpp b/src/gui/text/qrawfont.cpp
index 1bce909b0e..29394e9b7a 100644
--- a/src/gui/text/qrawfont.cpp
+++ b/src/gui/text/qrawfont.cpp
@@ -78,7 +78,7 @@ QT_BEGIN_NAMESPACE
    A QRawFont object represents a single, physical instance of a given font in a given pixel size.
    I.e. in the typical case it represents a set of TrueType or OpenType font tables and uses a
    user specified pixel size to convert metrics into logical pixel units. In can be used in
-   combination with the QGlyphs class to draw specific glyph indexes at specific positions, and
+   combination with the QGlyphRun class to draw specific glyph indexes at specific positions, and
    also have accessors to some relevant data in the physical font.
 
    QRawFont only provides support for the main font technologies: GDI and DirectWrite on Windows
@@ -87,9 +87,9 @@ QT_BEGIN_NAMESPACE
 
    QRawFont can be constructed in a number of ways:
    \list
-   \o \l It can be constructed by calling QTextLayout::glyphs() or QTextFragment::glyphs(). The
-         returned QGlyphs objects will contain QRawFont objects which represent the actual fonts
-         used to render each portion of the text.
+   \o \l It can be constructed by calling QTextLayout::glyphRuns() or QTextFragment::glyphRuns().
+         The returned QGlyphRun objects will contain QRawFont objects which represent the actual
+         fonts used to render each portion of the text.
    \o \l It can be constructed by passing a QFont object to QRawFont::fromFont(). The function
          will return a QRawFont object representing the font that will be selected as response to
          the QFont query and the selected writing system.
@@ -234,7 +234,7 @@ void QRawFont::loadFromData(const QByteArray &fontData,
    the pixel in the rasterization of the glyph. Otherwise, the image will be in the format of
    QImage::Format_A8 and each pixel will contain the opacity of the pixel in the rasterization.
 
-   \sa pathForGlyph(), QPainter::drawGlyphs()
+   \sa pathForGlyph(), QPainter::drawGlyphRun()
 */
 QImage QRawFont::alphaMapForGlyph(quint32 glyphIndex, AntialiasingType antialiasingType,
                                   const QTransform &transform) const
@@ -302,6 +302,58 @@ qreal QRawFont::descent() const
 }
 
 /*!
+   Returns the xHeight of this QRawFont in pixel units.
+
+   \sa QFontMetricsF::xHeight()
+*/
+qreal QRawFont::xHeight() const
+{
+    if (!isValid())
+        return 0.0;
+
+    return d->fontEngine->xHeight().toReal();
+}
+
+/*!
+   Returns the leading of this QRawFont in pixel units.
+
+   \sa QFontMetricsF::leading()
+*/
+qreal QRawFont::leading() const
+{
+    if (!isValid())
+        return 0.0;
+
+    return d->fontEngine->leading().toReal();
+}
+
+/*!
+   Returns the average character width of this QRawFont in pixel units.
+
+   \sa QFontMetricsF::averageCharWidth()
+*/
+qreal QRawFont::averageCharWidth() const
+{
+    if (!isValid())
+        return 0.0;
+
+    return d->fontEngine->averageCharWidth().toReal();
+}
+
+/*!
+   Returns the width of the widest character in the font.
+
+   \sa QFontMetricsF::maxWidth()
+*/
+qreal QRawFont::maxCharWidth() const
+{
+    if (!isValid())
+        return 0.0;
+
+    return d->fontEngine->maxCharWidth();
+}
+
+/*!
    Returns the pixel size set for this QRawFont. The pixel size affects how glyphs are
    rasterized, the size of glyphs returned by pathForGlyph(), and is used to convert
    internal metrics from design units to logical pixel units.
@@ -374,9 +426,9 @@ int QRawFont::weight() const
    underlying font. Note that in cases where there are other tables in the font that affect the
    shaping of the text, the returned glyph indexes will not correctly represent the rendering
    of the text. To get the correctly shaped text, you can use QTextLayout to lay out and shape the
-   text, and then call QTextLayout::glyphs() to get the set of glyph index list and QRawFont pairs.
+   text, and then call QTextLayout::glyphRuns() to get the set of glyph index list and QRawFont pairs.
 
-   \sa advancesForGlyphIndexes(), QGlyphs, QTextLayout::glyphs(), QTextFragment::glyphs()
+   \sa advancesForGlyphIndexes(), QGlyphRun, QTextLayout::glyphRuns(), QTextFragment::glyphRuns()
 */
 QVector<quint32> QRawFont::glyphIndexesForString(const QString &text) const
 {
@@ -535,17 +587,17 @@ QRawFont QRawFont::fromFont(const QFont &font, QFontDatabase::WritingSystem writ
     layout.beginLayout();
     QTextLine line = layout.createLine();
     layout.endLayout();
-    QList<QGlyphs> list = layout.glyphs();
+    QList<QGlyphRun> list = layout.glyphRuns();
     if (list.size()) {
         // Pick the one matches the family name we originally requested,
         // if none of them match, just pick the first one
         for (int i = 0; i < list.size(); i++) {
-            QGlyphs glyphs = list.at(i);
-            QRawFont rawfont = glyphs.font();
+            QGlyphRun glyphs = list.at(i);
+            QRawFont rawfont = glyphs.rawFont();
             if (rawfont.familyName() == font.family())
                 return rawfont;
         }
-        return list.at(0).font();
+        return list.at(0).rawFont();
     }
     return QRawFont();
 #else
diff --git a/src/gui/text/qrawfont.h b/src/gui/text/qrawfont.h
index 56aeefc8ff..900c07a7dd 100644
--- a/src/gui/text/qrawfont.h
+++ b/src/gui/text/qrawfont.h
@@ -103,6 +103,10 @@ public:
 
     qreal ascent() const;
     qreal descent() const;
+    qreal leading() const;
+    qreal xHeight() const;
+    qreal averageCharWidth() const;
+    qreal maxCharWidth() const;
 
     qreal unitsPerEm() const;
 
diff --git a/src/gui/text/qtextdocumentlayout.cpp b/src/gui/text/qtextdocumentlayout.cpp
index 450f7e100a..e6d5070340 100644
--- a/src/gui/text/qtextdocumentlayout.cpp
+++ b/src/gui/text/qtextdocumentlayout.cpp
@@ -3090,6 +3090,7 @@ void QTextDocumentLayoutPrivate::ensureLayouted(QFixed y) const
     if (currentLazyLayoutPosition == -1)
         return;
     const QSizeF oldSize = q->dynamicDocumentSize();
+    Q_UNUSED(oldSize);
 
     if (checkPoints.isEmpty())
         layoutStep();
diff --git a/src/gui/text/qtextlayout.cpp b/src/gui/text/qtextlayout.cpp
index 551ef69203..271af7ae82 100644
--- a/src/gui/text/qtextlayout.cpp
+++ b/src/gui/text/qtextlayout.cpp
@@ -50,8 +50,8 @@
 #include "qtextdocument_p.h"
 #include "qtextformat_p.h"
 #include "qpainterpath.h"
-#include "qglyphs.h"
-#include "qglyphs_p.h"
+#include "qglyphrun.h"
+#include "qglyphrun_p.h"
 #include "qrawfont.h"
 #include "qrawfont_p.h"
 #include <limits.h>
@@ -992,12 +992,12 @@ static inline QRectF clipIfValid(const QRectF &rect, const QRectF &clip)
 
     \since 4.8
 
-    \sa draw(), QPainter::drawGlyphs()
+    \sa draw(), QPainter::drawGlyphRun()
 */
 #if !defined(QT_NO_RAWFONT)
-QList<QGlyphs> QTextLayout::glyphs() const
+QList<QGlyphRun> QTextLayout::glyphRuns() const
 {
-    QList<QGlyphs> glyphs;
+    QList<QGlyphRun> glyphs;
     for (int i=0; i<d->lines.size(); ++i)
         glyphs += QTextLine(i, d).glyphs(-1, -1);
 
@@ -1209,8 +1209,6 @@ void QTextLayout::drawCursor(QPainter *p, const QPointF &pos, int cursorPosition
         d->itemize();
 
     QPointF position = pos + d->position;
-    QFixed pos_x = QFixed::fromReal(position.x());
-    QFixed pos_y = QFixed::fromReal(position.y());
 
     cursorPosition = qBound(0, cursorPosition, d->layoutData->string.length());
     int line = d->lineNumberForTextPosition(cursorPosition);
@@ -2093,15 +2091,15 @@ namespace {
 
     \since 4.8
 
-    \sa QTextLayout::glyphs()
+    \sa QTextLayout::glyphRuns()
 */
 #if !defined(QT_NO_RAWFONT)
-QList<QGlyphs> QTextLine::glyphs(int from, int length) const
+QList<QGlyphRun> QTextLine::glyphs(int from, int length) const
 {
     const QScriptLine &line = eng->lines[i];
 
     if (line.length == 0)
-        return QList<QGlyphs>();
+        return QList<QGlyphRun>();
 
     QHash<QFontEngine *, GlyphInfo> glyphLayoutHash;
 
@@ -2166,7 +2164,7 @@ QList<QGlyphs> QTextLine::glyphs(int from, int length) const
         }
     }
 
-    QHash<QPair<QFontEngine *, int>, QGlyphs> glyphsHash;
+    QHash<QPair<QFontEngine *, int>, QGlyphRun> glyphsHash;
 
     QList<QFontEngine *> keys = glyphLayoutHash.uniqueKeys();
     for (int i=0; i<keys.size(); ++i) {
@@ -2223,14 +2221,14 @@ QList<QGlyphs> QTextLine::glyphs(int from, int length) const
                 positions.append(positionsArray.at(i).toPointF() + pos);
             }
 
-            QGlyphs glyphIndexes;
+            QGlyphRun glyphIndexes;
             glyphIndexes.setGlyphIndexes(glyphs);
             glyphIndexes.setPositions(positions);
 
             glyphIndexes.setOverline(flags.testFlag(QTextItem::Overline));
             glyphIndexes.setUnderline(flags.testFlag(QTextItem::Underline));
             glyphIndexes.setStrikeOut(flags.testFlag(QTextItem::StrikeOut));
-            glyphIndexes.setFont(font);
+            glyphIndexes.setRawFont(font);
 
             QPair<QFontEngine *, int> key(fontEngine, int(flags));
             if (!glyphsHash.contains(key))
diff --git a/src/gui/text/qtextlayout.h b/src/gui/text/qtextlayout.h
index 6aa81f9e7c..8fe488a95a 100644
--- a/src/gui/text/qtextlayout.h
+++ b/src/gui/text/qtextlayout.h
@@ -49,7 +49,7 @@
 #include <QtCore/qobject.h>
 #include <QtGui/qevent.h>
 #include <QtGui/qtextformat.h>
-#include <QtGui/qglyphs.h>
+#include <QtGui/qglyphrun.h>
 #include <QtGui/qtextcursor.h>
 
 QT_BEGIN_HEADER
@@ -174,7 +174,7 @@ public:
     qreal maximumWidth() const;
 
 #if !defined(QT_NO_RAWFONT)
-    QList<QGlyphs> glyphs() const;
+    QList<QGlyphRun> glyphRuns() const;
 #endif
 
     QTextEngine *engine() const { return d; }
@@ -249,7 +249,7 @@ private:
     void layout_helper(int numGlyphs);
 
 #if !defined(QT_NO_RAWFONT)
-    QList<QGlyphs> glyphs(int from, int length) const;
+    QList<QGlyphRun> glyphs(int from, int length) const;
 #endif
 
     friend class QTextLayout;
diff --git a/src/gui/text/qtextobject.cpp b/src/gui/text/qtextobject.cpp
index 5c1c8b9edc..8dabcc771b 100644
--- a/src/gui/text/qtextobject.cpp
+++ b/src/gui/text/qtextobject.cpp
@@ -1664,25 +1664,25 @@ QTextBlock::iterator &QTextBlock::iterator::operator--()
     Returns the glyphs of this text fragment. The positions of the glyphs are
     relative to the position of the QTextBlock's layout.
 
-    \sa QGlyphs, QTextBlock::layout(), QTextLayout::position(), QPainter::drawGlyphs()
+    \sa QGlyphRun, QTextBlock::layout(), QTextLayout::position(), QPainter::drawGlyphRun()
 */
 #if !defined(QT_NO_RAWFONT)
-QList<QGlyphs> QTextFragment::glyphs() const
+QList<QGlyphRun> QTextFragment::glyphRuns() const
 {
     if (!p || !n)
-        return QList<QGlyphs>();
+        return QList<QGlyphRun>();
 
     int pos = position();
     int len = length();
     if (len == 0)
-        return QList<QGlyphs>();
+        return QList<QGlyphRun>();
 
     int blockNode = p->blockMap().findNode(pos);
 
     const QTextBlockData *blockData = p->blockMap().fragment(blockNode);
     QTextLayout *layout = blockData->layout;
 
-    QList<QGlyphs> ret;
+    QList<QGlyphRun> ret;
     for (int i=0; i<layout->lineCount(); ++i) {
         QTextLine textLine = layout->lineAt(i);
         ret += textLine.glyphs(pos, len);
diff --git a/src/gui/text/qtextobject.h b/src/gui/text/qtextobject.h
index ad8e6579dc..1588349a3f 100644
--- a/src/gui/text/qtextobject.h
+++ b/src/gui/text/qtextobject.h
@@ -44,7 +44,7 @@
 
 #include <QtCore/qobject.h>
 #include <QtGui/qtextformat.h>
-#include <QtGui/qglyphs.h>
+#include <QtGui/qglyphrun.h>
 
 QT_BEGIN_HEADER
 
@@ -317,7 +317,7 @@ public:
     QString text() const;
 
 #if !defined(QT_NO_RAWFONT)
-    QList<QGlyphs> glyphs() const;
+    QList<QGlyphRun> glyphRuns() const;
 #endif
 
 private:
diff --git a/src/gui/text/text.pri b/src/gui/text/text.pri
index 24f9c5f0e4..6357dec1d2 100644
--- a/src/gui/text/text.pri
+++ b/src/gui/text/text.pri
@@ -38,10 +38,10 @@ HEADERS += \
 	text/qtextodfwriter_p.h \
 	text/qstatictext_p.h \
 	text/qstatictext.h \
-        text/qglyphs.h \
-        text/qglyphs_p.h \
         text/qrawfont.h \
-        text/qrawfont_p.h
+        text/qrawfont_p.h \
+    text/qglyphrun.h \
+    text/qglyphrun_p.h
 
 SOURCES += \
 	text/qfont.cpp \
@@ -71,8 +71,8 @@ SOURCES += \
 	text/qzip.cpp \
 	text/qtextodfwriter.cpp \
 	text/qstatictext.cpp \
-        text/qglyphs.cpp \
-        text/qrawfont.cpp
+        text/qrawfont.cpp \
+    text/qglyphrun.cpp
 
 win32 {
 	SOURCES += \