Changeset 846 for trunk/src/gui/painting/qpainter.cpp

Timestamp:

May 5, 2011, 5:36:53 AM (14 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/gui/painting/qpainter.cpp (modified) (54 diffs)

trunk/src/gui/painting/qpainter.cpp

@@ -1 +1 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
@@ -39 +39 @@
 **
 ****************************************************************************/
+
 // QtCore
 #include <qdebug.h>
@@ -70 +71 @@
 #include <private/qpaintengine_raster_p.h>
 #include <private/qmath_p.h>
+#include <qstatictext.h>
+#include <private/qstatictext_p.h>
+#include <private/qstylehelper_p.h>
 
 QT_BEGIN_NAMESPACE
@@ -87 +91 @@
                     int tabstops, int* tabarray, int tabarraylen,
                     QPainter *painter);
+static void drawTextItemDecoration(QPainter *painter, const QPointF &pos, const QFontEngine *fe,
+                                   QTextCharFormat::UnderlineStyle underlineStyle,
+                                   const QTextItem::RenderFlags flags, qreal width,
+                                   const QTextCharFormat &charFormat);
+// Helper function to calculate left most position, width and flags for decoration drawing
+static void drawDecorationForGlyphs(QPainter *painter, const glyph_t *glyphArray,
+                                    const QFixedPoint *positions, int glyphCount,
+                                    QFontEngine *fontEngine, const QFont &font,
+                                    const QTextCharFormat &charFormat);
 
 static inline QGradient::CoordinateMode coordinateMode(const QBrush &brush)
@@ -684 +697 @@
         skip = false;
 
-        QBrush penBrush = s->pen.brush();
-        Qt::BrushStyle brushStyle = s->brush.style();
-        Qt::BrushStyle penBrushStyle = penBrush.style();
+        QBrush penBrush = (qpen_style(s->pen) == Qt::NoPen) ? QBrush(Qt::NoBrush) : qpen_brush(s->pen);
+        Qt::BrushStyle brushStyle = qbrush_style(s->brush);
+        Qt::BrushStyle penBrushStyle = qbrush_style(penBrush);
         alpha = (penBrushStyle != Qt::NoBrush
                  && (penBrushStyle < Qt::LinearGradientPattern && penBrush.color().alpha() != 255)
@@ -968 +981 @@
     device on which the painter paints, and paintEngine() returns the
     paint engine that the painter is currently operating on. For more
-    information, see \l {The Paint System} documentation.
+    information, see the \l {Paint System}.
 
     Sometimes it is desirable to make someone else paint on an unusual
@@ -1013 +1026 @@
     \o viewport(), window(), worldTransform() make up the painter's coordinate
         transformation system. For more information, see the \l
-        {Coordinate Transformations} section and the \l {The Coordinate
+        {Coordinate Transformations} section and the \l {Coordinate
         System} documentation.
 
@@ -1220 +1233 @@
     worldTransform(). A matrix transforms a point in the plane to another
     point. For more information about the transformation matrix, see
-    the \l {The Coordinate System} and QTransform documentation.
+    the \l {Coordinate System} and QTransform documentation.
 
     The setWorldTransform() function can replace or add to the currently
@@ -1242 +1255 @@
     transformation matrix.
 
-    See also \l {The Coordinate System} documentation.
+    See also \l {Coordinate System}
 
     \section1 Clipping
@@ -1561 +1574 @@
         d->engine->setDirty(QPaintEngine::DirtyFont);
     }
-    d->state->layoutDirection = widget->layoutDirection();
 }
 
@@ -1871 +1883 @@
         initFrom(widget);
     } else {
-        d->state->layoutDirection = QApplication::layoutDirection();
+        d->state->layoutDirection = Qt::LayoutDirectionAuto;
         // make sure we have a font compatible with the paintdevice
         d->state->deviceFont = d->state->font = QFont(d->state->deviceFont, device());
@@ -2389 +2401 @@
         return;
     }
+    if (d->state->composition_mode == mode)
+        return;
     if (d->extended) {
         d->state->composition_mode = mode;
@@ -2704 +2718 @@
 
     if (d->extended) {
-        if (!hasClipping() && (op == Qt::IntersectClip || op == Qt::UniteClip))
+        if ((!d->state->clipEnabled && op != Qt::NoClip) || (d->state->clipOperation == Qt::NoClip && op == Qt::UniteClip))
             op = Qt::ReplaceClip;
 
@@ -2762 +2776 @@
     }
 
-    if (!hasClipping() && (op == Qt::IntersectClip || op == Qt::UniteClip))
+    if ((!d->state->clipEnabled && op != Qt::NoClip) || (d->state->clipOperation == Qt::NoClip && op == Qt::UniteClip))
         op = Qt::ReplaceClip;
 
@@ -2817 +2831 @@
     }
 
-    if (!hasClipping() && (op == Qt::IntersectClip || op == Qt::UniteClip))
+    if ((!d->state->clipEnabled && op != Qt::NoClip) || (d->state->clipOperation == Qt::NoClip && op == Qt::UniteClip))
         op = Qt::ReplaceClip;
 
@@ -2878 +2892 @@
 
     For more information about the coordinate system, transformations
-    and window-viewport conversion, see \l {The Coordinate System}
-    documentation.
+    and window-viewport conversion, see \l {Coordinate System}.
 
     \sa setWorldTransform(), QTransform
@@ -2899 +2912 @@
 
     \sa {QPainter#Coordinate Transformations}{Coordinate Transformations},
-    {The Coordinate System}
+    {Coordinate System}
 */
 
@@ -3042 +3055 @@
     false.
 
-    \sa setWorldMatrixEnabled(), worldTransform(), {The Coordinate System}
+    \sa setWorldMatrixEnabled(), worldTransform(), {Coordinate System}
 */
 
@@ -3223 +3236 @@
     }
 
-    if (!hasClipping() && (op == Qt::IntersectClip || op == Qt::UniteClip))
+    if ((!d->state->clipEnabled && op != Qt::NoClip) || (d->state->clipOperation == Qt::NoClip && op == Qt::UniteClip))
         op = Qt::ReplaceClip;
 
@@ -3384 +3397 @@
     \endtable
 
-    \sa drawLines(), drawPolyline(), {The Coordinate System}
+    \sa drawLines(), drawPolyline(), {Coordinate System}
 */
 
@@ -3431 +3444 @@
     \endtable
 
-    \sa drawRects(), drawPolygon(), {The Coordinate System}
+    \sa drawRects(), drawPolygon(), {Coordinate System}
 */
 
@@ -3595 +3608 @@
     pen's color.
 
-    \sa {The Coordinate System}
+    \sa {Coordinate System}
 */
 
@@ -3617 +3630 @@
     the current pen's color.
 
-    \sa {The Coordinate System}
+    \sa {Coordinate System}
 */
 void QPainter::drawPoints(const QPointF *points, int pointCount)
@@ -4223 +4236 @@
     \endtable
 
-    \sa drawPie(), {The Coordinate System}
+    \sa drawPie(), {Coordinate System}
 */
 void QPainter::drawEllipse(const QRectF &r)
@@ -4237 +4250 @@
 
     QRectF rect(r.normalized());
-    if (rect.isEmpty())
-        return;
 
     if (d->extended) {
@@ -4280 +4291 @@
 
     QRect rect(r.normalized());
-    if (rect.isEmpty())
-        return;
 
     if (d->extended) {
@@ -4353 +4362 @@
     \endtable
 
-    \sa drawPie(), drawChord(), {The Coordinate System}
+    \sa drawPie(), drawChord(), {Coordinate System}
 */
 
@@ -4417 +4426 @@
     \endtable
 
-    \sa drawEllipse(), drawChord(), {The Coordinate System}
+    \sa drawEllipse(), drawChord(), {Coordinate System}
 */
 void QPainter::drawPie(const QRectF &r, int a, int alen)
@@ -4486 +4495 @@
     \endtable
 
-    \sa drawArc(), drawPie(), {The Coordinate System}
+    \sa drawArc(), drawPie(), {Coordinate System}
 */
 void QPainter::drawChord(const QRectF &r, int a, int alen)
@@ -4777 +4786 @@
     \endtable
 
-    \sa drawLines(), drawPolygon(), {The Coordinate System}
+    \sa drawLines(), drawPolygon(), {Coordinate System}
 */
 void QPainter::drawPolyline(const QPointF *points, int pointCount)
@@ -4916 +4925 @@
     rules.
 
-    \sa  drawConvexPolygon(), drawPolyline(), {The Coordinate System}
+    \sa  drawConvexPolygon(), drawPolyline(), {Coordinate System}
 */
 void QPainter::drawPolygon(const QPointF *points, int pointCount, Qt::FillRule fillRule)
@@ -5067 +5076 @@
     be faster than the drawPolygon() function.
 
-    \sa drawPolygon(), drawPolyline(), {The Coordinate System}
+    \sa drawPolygon(), drawPolyline(), {Coordinate System}
 */
 
@@ -5412 +5421 @@
         setBackgroundMode(Qt::TransparentMode);
         setRenderHint(Antialiasing, renderHints() & SmoothPixmapTransform);
-        QBrush brush(d->state->pen.color(), pm);
+        QBrush brush;
+
+        if (sw == pm.width() && sh == pm.height())
+            brush = QBrush(d->state->pen.color(), pm);
+        else
+            brush = QBrush(d->state->pen.color(), pm.copy(sx, sy, sw, sh));
+
         setBrush(brush);
         setPen(Qt::NoPen);
-        setBrushOrigin(QPointF(-sx, -sy));
 
         drawRect(QRectF(0, 0, sw, sh));
@@ -5698 +5712 @@
 }
 
+
+void qt_draw_glyphs(QPainter *painter, const quint32 *glyphArray, const QPointF *positionArray,
+                    int glyphCount)
+{
+    QPainterPrivate *painter_d = QPainterPrivate::get(painter);
+    painter_d->drawGlyphs(glyphArray, positionArray, glyphCount);
+}
+
+void QPainterPrivate::drawGlyphs(const quint32 *glyphArray, const QPointF *positionArray,
+                                 int glyphCount)
+{
+    updateState(state);
+
+    QFontEngine *fontEngine = state->font.d->engineForScript(QUnicodeTables::Common);
+
+    while (fontEngine->type() == QFontEngine::Multi) {
+        // Pick engine based on first glyph in array if we are using a multi engine.
+        // (all glyphs must be for same font)
+        int engineIdx = 0;
+        if (glyphCount > 0)
+            engineIdx = glyphArray[0] >> 24;
+
+        fontEngine = static_cast<QFontEngineMulti *>(fontEngine)->engine(engineIdx);
+    }
+
+    QVarLengthArray<QFixedPoint, 128> positions;
+    for (int i=0; i<glyphCount; ++i) {
+        QFixedPoint fp = QFixedPoint::fromPointF(positionArray[i]);
+        positions.append(fp);
+    }
+
+    if (extended != 0) {
+        QStaticTextItem staticTextItem;
+        staticTextItem.color = state->pen.color();
+        staticTextItem.font = state->font;
+        staticTextItem.setFontEngine(fontEngine);
+        staticTextItem.numGlyphs = glyphCount;
+        staticTextItem.glyphs = reinterpret_cast<glyph_t *>(const_cast<glyph_t *>(glyphArray));
+        staticTextItem.glyphPositions = positions.data();
+
+        extended->drawStaticTextItem(&staticTextItem);
+    } else {
+        QTextItemInt textItem;
+        textItem.f = &state->font;
+        textItem.fontEngine = fontEngine;
+
+        QVarLengthArray<QFixed, 128> advances(glyphCount);
+        QVarLengthArray<QGlyphJustification, 128> glyphJustifications(glyphCount);
+        QVarLengthArray<HB_GlyphAttributes, 128> glyphAttributes(glyphCount);
+        qMemSet(glyphAttributes.data(), 0, glyphAttributes.size() * sizeof(HB_GlyphAttributes));
+        qMemSet(advances.data(), 0, advances.size() * sizeof(QFixed));
+        qMemSet(glyphJustifications.data(), 0, glyphJustifications.size() * sizeof(QGlyphJustification));
+
+        textItem.glyphs.numGlyphs = glyphCount;
+        textItem.glyphs.glyphs = reinterpret_cast<HB_Glyph *>(const_cast<quint32 *>(glyphArray));
+        textItem.glyphs.offsets = positions.data();
+        textItem.glyphs.advances_x = advances.data();
+        textItem.glyphs.advances_y = advances.data();
+        textItem.glyphs.justifications = glyphJustifications.data();
+        textItem.glyphs.attributes = glyphAttributes.data();
+
+        engine->drawTextItem(QPointF(0, 0), textItem);
+    }
+}
+
+/*!
+
+    \fn void QPainter::drawStaticText(const QPoint &topLeftPosition, const QStaticText &staticText)
+    \since 4.7
+    \overload
+
+    Draws the \a staticText at the \a topLeftPosition.
+
+    \note The y-position is used as the top of the font.
+
+*/
+
+/*!
+    \fn void QPainter::drawStaticText(int left, int top, const QStaticText &staticText)
+    \since 4.7
+    \overload
+
+    Draws the \a staticText at coordinates \a left and \a top.
+
+    \note The y-position is used as the top of the font.
+*/
+
 /*!
     \fn void QPainter::drawText(const QPointF &position, const QString &text)
@@ -5721 +5822 @@
 
 /*!
+    \since 4.7
+
+    Draws the given \a staticText at the given \a topLeftPosition.
+
+    The text will be drawn using the font and the transformation set on the painter. If the
+    font and/or transformation set on the painter are different from the ones used to initialize
+    the layout of the QStaticText, then the layout will have to be recalculated. Use
+    QStaticText::prepare() to initialize \a staticText with the font and transformation with which
+    it will later be drawn.
+
+    If \a topLeftPosition is not the same as when \a staticText was initialized, or when it was
+    last drawn, then there will be a slight overhead when translating the text to its new position.
+
+    \note If the painter's transformation is not affine, then \a staticText will be drawn using
+    regular calls to drawText(), losing any potential for performance improvement.
+
+    \note The y-position is used as the top of the font.
+
+    \sa QStaticText
+*/
+void QPainter::drawStaticText(const QPointF &topLeftPosition, const QStaticText &staticText)
+{
+    Q_D(QPainter);
+    if (!d->engine || staticText.text().isEmpty() || pen().style() == Qt::NoPen)
+        return;
+
+    QStaticTextPrivate *staticText_d =
+            const_cast<QStaticTextPrivate *>(QStaticTextPrivate::get(&staticText));
+
+    if (font() != staticText_d->font) {
+        staticText_d->font = font();
+        staticText_d->needsRelayout = true;
+    }
+
+    // If we don't have an extended paint engine, or if the painter is projected,
+    // we go through standard code path
+    if (d->extended == 0 || !d->state->matrix.isAffine()) {
+        staticText_d->paintText(topLeftPosition, this);
+        return;
+    }
+
+    bool paintEngineSupportsTransformations = d->extended->type() == QPaintEngine::OpenGL2
+                                           || d->extended->type() == QPaintEngine::OpenVG
+                                           || d->extended->type() == QPaintEngine::OpenGL;
+
+    if (paintEngineSupportsTransformations && !staticText_d->untransformedCoordinates) {
+        staticText_d->untransformedCoordinates = true;
+        staticText_d->needsRelayout = true;
+    } else if (!paintEngineSupportsTransformations && staticText_d->untransformedCoordinates) {
+        staticText_d->untransformedCoordinates = false;
+        staticText_d->needsRelayout = true;
+    }
+
+    // Don't recalculate entire layout because of translation, rather add the dx and dy
+    // into the position to move each text item the correct distance.
+    QPointF transformedPosition = topLeftPosition;
+    if (!staticText_d->untransformedCoordinates)
+        transformedPosition = transformedPosition * d->state->matrix;
+    QTransform oldMatrix;
+
+    // The translation has been applied to transformedPosition. Remove translation
+    // component from matrix.
+    if (d->state->matrix.isTranslating() && !staticText_d->untransformedCoordinates) {
+        qreal m11 = d->state->matrix.m11();
+        qreal m12 = d->state->matrix.m12();
+        qreal m13 = d->state->matrix.m13();
+        qreal m21 = d->state->matrix.m21();
+        qreal m22 = d->state->matrix.m22();
+        qreal m23 = d->state->matrix.m23();
+        qreal m33 = d->state->matrix.m33();
+
+        oldMatrix = d->state->matrix;
+        d->state->matrix.setMatrix(m11, m12, m13,
+                                   m21, m22, m23,
+                                   0.0, 0.0, m33);
+    }
+
+    // If the transform is not identical to the text transform,
+    // we have to relayout the text (for other transformations than plain translation)
+    bool staticTextNeedsReinit = staticText_d->needsRelayout;
+    if (!staticText_d->untransformedCoordinates && staticText_d->matrix != d->state->matrix) {
+        staticText_d->matrix = d->state->matrix;
+        staticTextNeedsReinit = true;
+    }
+
+    // Recreate the layout of the static text because the matrix or font has changed
+    if (staticTextNeedsReinit)
+        staticText_d->init();
+
+    if (transformedPosition != staticText_d->position) { // Translate to actual position
+        QFixed fx = QFixed::fromReal(transformedPosition.x());
+        QFixed fy = QFixed::fromReal(transformedPosition.y());
+        QFixed oldX = QFixed::fromReal(staticText_d->position.x());
+        QFixed oldY = QFixed::fromReal(staticText_d->position.y());
+        for (int item=0; item<staticText_d->itemCount;++item) {
+            QStaticTextItem *textItem = staticText_d->items + item;
+            for (int i=0; i<textItem->numGlyphs; ++i) {
+                textItem->glyphPositions[i].x += fx - oldX;
+                textItem->glyphPositions[i].y += fy - oldY;
+            }
+            textItem->userDataNeedsUpdate = true;
+        }
+
+        staticText_d->position = transformedPosition;
+    }
+
+    QPen oldPen = d->state->pen;
+    QColor currentColor = oldPen.color();
+    for (int i=0; i<staticText_d->itemCount; ++i) {
+        QStaticTextItem *item = staticText_d->items + i;
+        if (item->color.isValid() && currentColor != item->color) {
+            setPen(item->color);
+            currentColor = item->color;
+        }
+        d->extended->drawStaticTextItem(item);
+
+        drawDecorationForGlyphs(this, item->glyphs, item->glyphPositions,
+                                item->numGlyphs, item->fontEngine(), staticText_d->font,
+                                QTextCharFormat());
+    }
+    if (currentColor != oldPen.color())
+        setPen(oldPen);
+
+    if (!staticText_d->untransformedCoordinates && oldMatrix.isTranslating())
+        d->state->matrix = oldMatrix;
+}
+
+/*!
    \internal
 */
@@ -5734 +5963 @@
     if (!d->engine || str.isEmpty() || pen().style() == Qt::NoPen)
         return;
+
+    if (tf & Qt::TextBypassShaping) {
+        // Skip harfbuzz complex shaping, shape using glyph advances only
+        int len = str.length();
+        int numGlyphs = len;
+        QVarLengthGlyphLayoutArray glyphs(len);
+        QFontEngine *fontEngine = d->state->font.d->engineForScript(QUnicodeTables::Common);
+        if (!fontEngine->stringToCMap(str.data(), len, &glyphs, &numGlyphs, 0)) {
+            glyphs.resize(numGlyphs);
+            if (!fontEngine->stringToCMap(str.data(), len, &glyphs, &numGlyphs, 0))
+                Q_ASSERT_X(false, Q_FUNC_INFO, "stringToCMap shouldn't fail twice");
+        }
+
+        QTextItemInt gf(glyphs, &d->state->font, str.data(), len, fontEngine);
+        drawTextItem(p, gf);
+        return;
+    }
 
     QStackTextEngine engine(str, d->state->font);
@@ -5940 +6186 @@
     By default, QPainter draws text anti-aliased.
 
-    \note The y-position is used as the baseline of the font.
+    \note The y-position is used as the top of the font.
 
     \sa Qt::AlignmentFlag, Qt::TextFlag
@@ -6015 +6261 @@
     const qreal radiusBase = qMax(qreal(1), maxRadius);
 
-    QString key = QLatin1String("WaveUnderline-");
-    key += pen.color().name();
-    key += QLatin1Char('-');
-    key += QString::number(radiusBase);
+    QString key = QLatin1Literal("WaveUnderline-")
+                  % pen.color().name()
+                  % HexString<qreal>(radiusBase);
 
     QPixmap pixmap;
@@ -6063 +6308 @@
 }
 
-static void drawTextItemDecoration(QPainter *painter, const QPointF &pos, const QTextItemInt &ti)
-{
-    QTextCharFormat::UnderlineStyle underlineStyle = ti.underlineStyle;
+static void drawTextItemDecoration(QPainter *painter, const QPointF &pos, const QFontEngine *fe,
+                                   QTextCharFormat::UnderlineStyle underlineStyle,
+                                   const QTextItem::RenderFlags flags, qreal width,
+                                   const QTextCharFormat &charFormat)
+{
     if (underlineStyle == QTextCharFormat::NoUnderline
-        && !(ti.flags & (QTextItem::StrikeOut | QTextItem::Overline)))
-        return;
-
-    QFontEngine *fe = ti.fontEngine;
+        && !(flags & (QTextItem::StrikeOut | QTextItem::Overline)))
+        return;
 
     const QPen oldPen = painter->pen();
@@ -6080 +6325 @@
     pen.setCapStyle(Qt::FlatCap);
 
-    QLineF line(pos.x(), pos.y(), pos.x() + ti.width.toReal(), pos.y());
+    QLineF line(pos.x(), pos.y(), pos.x() + width, pos.y());
 
     const qreal underlineOffset = fe->underlinePosition().toReal();
@@ -6095 +6340 @@
         painter->translate(0, pos.y() + 1);
 
-        QColor uc = ti.charFormat.underlineColor();
+        QColor uc = charFormat.underlineColor();
         if (uc.isValid())
             pen.setColor(uc);
@@ -6101 +6346 @@
         // Adapt wave to underlineOffset or pen width, whatever is larger, to make it work on all platforms
         const QPixmap wave = generateWavyPixmap(qMax(underlineOffset, pen.widthF()), pen);
-        const int descent = (int) ti.descent.toReal();
+        const int descent = (int) fe->descent().toReal();
 
         painter->setBrushOrigin(painter->brushOrigin().x(), 0);
-        painter->fillRect(pos.x(), 0, qCeil(ti.width.toReal()), qMin(wave.height(), descent), wave);
+        painter->fillRect(pos.x(), 0, qCeil(width), qMin(wave.height(), descent), wave);
         painter->restore();
     } else if (underlineStyle != QTextCharFormat::NoUnderline) {
         QLineF underLine(line.x1(), underlinePos, line.x2(), underlinePos);
 
-        QColor uc = ti.charFormat.underlineColor();
+        QColor uc = charFormat.underlineColor();
         if (uc.isValid())
             pen.setColor(uc);
@@ -6121 +6366 @@
     pen.setColor(oldPen.color());
 
-    if (ti.flags & QTextItem::StrikeOut) {
+    if (flags & QTextItem::StrikeOut) {
         QLineF strikeOutLine = line;
         strikeOutLine.translate(0., - fe->ascent().toReal() / 3.);
@@ -6128 +6373 @@
     }
 
-    if (ti.flags & QTextItem::Overline) {
+    if (flags & QTextItem::Overline) {
         QLineF overLine = line;
         overLine.translate(0., - fe->ascent().toReal());
@@ -6137 +6382 @@
     painter->setPen(oldPen);
     painter->setBrush(oldBrush);
+}
+
+static void drawDecorationForGlyphs(QPainter *painter, const glyph_t *glyphArray,
+                                    const QFixedPoint *positions, int glyphCount,
+                                    QFontEngine *fontEngine, const QFont &font,
+                                    const QTextCharFormat &charFormat)
+{
+    if (!(font.underline() || font.strikeOut() || font.overline()))
+        return;
+
+    QFixed leftMost;
+    QFixed rightMost;
+    QFixed baseLine;
+    for (int i=0; i<glyphCount; ++i) {
+        glyph_metrics_t gm = fontEngine->boundingBox(glyphArray[i]);
+        if (i == 0 || leftMost > positions[i].x)
+            leftMost = positions[i].x;
+
+        // We don't support glyphs that do not share a common baseline. If this turns out to
+        // be a relevant use case, then we need to find clusters of glyphs that share a baseline
+        // and do a drawTextItemDecorations call per cluster.
+        if (i == 0 || baseLine < positions[i].y)
+            baseLine = positions[i].y;
+
+        // We use the advance rather than the actual bounds to match the algorithm in drawText()
+        if (i == 0 || rightMost < positions[i].x + gm.xoff)
+            rightMost = positions[i].x + gm.xoff;
+    }
+
+    QFixed width = rightMost - leftMost;
+    QTextItem::RenderFlags flags = 0;
+
+    if (font.underline())
+        flags |= QTextItem::Underline;
+    if (font.overline())
+        flags |= QTextItem::Overline;
+    if (font.strikeOut())
+        flags |= QTextItem::StrikeOut;
+
+    drawTextItemDecoration(painter, QPointF(leftMost.toReal(), baseLine.toReal()),
+                           fontEngine,
+                           font.underline() ? QTextCharFormat::SingleUnderline
+                                            : QTextCharFormat::NoUnderline, flags,
+                           width.toReal(), charFormat);
 }
 
@@ -6269 +6558 @@
             d->engine->drawTextItem(p, ti);
     }
-    drawTextItemDecoration(this, p, ti);
+    drawTextItemDecoration(this, p, ti.fontEngine, ti.underlineStyle, ti.flags, ti.width.toReal(),
+                           ti.charFormat);
 
     if (d->state->renderHints != oldRenderHints) {
@@ -6909 +7199 @@
     rectangle.
 
-    \sa window(), viewTransformEnabled(), {The Coordinate
+    \sa window(), viewTransformEnabled(), {Coordinate
     System#Window-Viewport Conversion}{Window-Viewport Conversion}
 */
@@ -6973 +7263 @@
     rectangle.
 
-    \sa viewport(), viewTransformEnabled() {The Coordinate
+    \sa viewport(), viewTransformEnabled() {Coordinate
     System#Window-Viewport Conversion}{Window-Viewport Conversion}
 */
@@ -7057 +7347 @@
     view transformations if \a enable is false.
 
-    \sa viewTransformEnabled(), {The Coordinate System#Window-Viewport
+    \sa viewTransformEnabled(), {Coordinate System#Window-Viewport
     Conversion}{Window-Viewport Conversion}
 */
@@ -7807 +8097 @@
             QTextLine line = textLayout.lineAt(i);
 
-            qreal advance = textLayout.engine()->lines[i].textAdvance.toReal();
+            qreal advance = line.horizontalAdvance();
             if (tf & Qt::AlignRight)
                 xoff = r.width() - advance;
@@ -7826 +8116 @@
     to the specified \a direction.
 
-    \sa layoutDirection(), drawText(), {QPainter#Settings}{Settings}
+    The default is Qt::LayoutDirectionAuto, which will implicitly determine the
+    direction from the text drawn.
+
+    \sa QTextOption::setTextDirection(), layoutDirection(), drawText(), {QPainter#Settings}{Settings}
 */
 void QPainter::setLayoutDirection(Qt::LayoutDirection direction)
@@ -7838 +8131 @@
     Returns the layout direction used by the painter when drawing text.
 
-    \sa setLayoutDirection(), drawText(), {QPainter#Settings}{Settings}
+    \sa QTextOption::textDirection(), setLayoutDirection(), drawText(), {QPainter#Settings}{Settings}
 */
 Qt::LayoutDirection QPainter::layoutDirection() const
 {
     Q_D(const QPainter);
-    return d->state ? d->state->layoutDirection : Qt::LeftToRight;
+    return d->state ? d->state->layoutDirection : Qt::LayoutDirectionAuto;
 }
 
@@ -8506 +8799 @@
 
 /*!
-    Returns wether clipping is enabled or not in the current paint
+    Returns whether clipping is enabled or not in the current paint
     engine state.
 
@@ -8716 +9009 @@
 }
 
+/*!
+    \since 4.7
+
+    This function is used to draw \a pixmap, or a sub-rectangle of \a pixmap,
+    at multiple positions with different scale, rotation and opacity. \a
+    fragments is an array of \a fragmentCount elements specifying the
+    parameters used to draw each pixmap fragment. The \a hints
+    parameter can be used to pass in drawing hints.
+
+    This function is potentially faster than multiple calls to drawPixmap(),
+    since the backend can optimize state changes.
+
+    \sa QPainter::PixmapFragment, QPainter::PixmapFragmentHint
+*/
+
+void QPainter::drawPixmapFragments(const PixmapFragment *fragments, int fragmentCount,
+                                   const QPixmap &pixmap, PixmapFragmentHints hints)
+{
+    Q_D(QPainter);
+
+    if (!d->engine || pixmap.isNull())
+        return;
+
+#ifndef QT_NO_DEBUG
+    for (int i = 0; i < fragmentCount; ++i) {
+        QRectF sourceRect(fragments[i].sourceLeft, fragments[i].sourceTop,
+                          fragments[i].width, fragments[i].height);
+        if (!(QRectF(pixmap.rect()).contains(sourceRect)))
+            qWarning("QPainter::drawPixmapFragments - the source rect is not contained by the pixmap's rectangle");
+    }
+#endif
+
+    if (d->engine->isExtended()) {
+        d->extended->drawPixmapFragments(fragments, fragmentCount, pixmap, hints);
+    } else {
+        qreal oldOpacity = opacity();
+        QTransform oldTransform = transform();
+
+        for (int i = 0; i < fragmentCount; ++i) {
+            QTransform transform = oldTransform;
+            qreal xOffset = 0;
+            qreal yOffset = 0;
+            if (fragments[i].rotation == 0) {
+                xOffset = fragments[i].x;
+                yOffset = fragments[i].y;
+            } else {
+                transform.translate(fragments[i].x, fragments[i].y);
+                transform.rotate(fragments[i].rotation);
+            }
+            setOpacity(oldOpacity * fragments[i].opacity);
+            setTransform(transform);
+
+            qreal w = fragments[i].scaleX * fragments[i].width;
+            qreal h = fragments[i].scaleY * fragments[i].height;
+            QRectF sourceRect(fragments[i].sourceLeft, fragments[i].sourceTop,
+                              fragments[i].width, fragments[i].height);
+            drawPixmap(QRectF(-0.5 * w + xOffset, -0.5 * h + yOffset, w, h), pixmap, sourceRect);
+        }
+
+        setOpacity(oldOpacity);
+        setTransform(oldTransform);
+    }
+}
+
+/*!
+    \since 4.7
+    \class QPainter::PixmapFragment
+
+    \brief This class is used in conjunction with the
+    QPainter::drawPixmapFragments() function to specify how a pixmap, or
+    sub-rect of a pixmap, is drawn.
+
+    The \a sourceLeft, \a sourceTop, \a width and \a height variables are used
+    as a source rectangle within the pixmap passed into the
+    QPainter::drawPixmapFragments() function. The variables \a x, \a y, \a
+    width and \a height are used to calculate the target rectangle that is
+    drawn. \a x and \a y denotes the center of the target rectangle. The \a
+    width and \a height in the target rectangle is scaled by the \a scaleX and
+    \a scaleY values. The resulting target rectangle is then rotated \a
+    rotation degrees around the \a x, \a y center point.
+
+    \sa QPainter::drawPixmapFragments()
+*/
+
+/*!
+    \since 4.7
+
+    This is a convenience function that returns a QPainter::PixmapFragment that is
+    initialized with the \a pos, \a sourceRect, \a scaleX, \a scaleY, \a
+    rotation, \a opacity parameters.
+*/
+
+QPainter::PixmapFragment QPainter::PixmapFragment::create(const QPointF &pos, const QRectF &sourceRect,
+                                              qreal scaleX, qreal scaleY, qreal rotation,
+                                              qreal opacity)
+{
+    PixmapFragment fragment = {pos.x(), pos.y(), sourceRect.x(), sourceRect.y(), sourceRect.width(),
+                               sourceRect.height(), scaleX, scaleY, rotation, opacity};
+    return fragment;
+}
+
+/*!
+    \variable QPainter::PixmapFragment::x
+    \brief the x coordinate of center point in the target rectangle.
+*/
+
+/*!
+    \variable QPainter::PixmapFragment::y
+    \brief the y coordinate of the center point in the target rectangle.
+*/
+
+/*!
+    \variable QPainter::PixmapFragment::sourceLeft
+    \brief the left coordinate of the source rectangle.
+*/
+
+/*!
+    \variable QPainter::PixmapFragment::sourceTop
+    \brief the top coordinate of the source rectangle.
+*/
+
+/*!
+    \variable QPainter::PixmapFragment::width
+
+    \brief the width of the source rectangle and is used to calculate the width
+    of the target rectangle.
+*/
+
+/*!
+    \variable QPainter::PixmapFragment::height
+
+    \brief the height of the source rectangle and is used to calculate the
+    height of the target rectangle.
+*/
+
+/*!
+    \variable QPainter::PixmapFragment::scaleX
+    \brief the horizontal scale of the target rectangle.
+*/
+
+/*!
+    \variable QPainter::PixmapFragment::scaleY
+    \brief the vertical scale of the target rectangle.
+*/
+
+/*!
+    \variable QPainter::PixmapFragment::rotation
+
+    \brief the rotation of the target rectangle in degrees. The target
+    rectangle is rotated after it has been scaled.
+*/
+
+/*!
+    \variable QPainter::PixmapFragment::opacity
+
+    \brief the opacity of the target rectangle, where 0.0 is fully transparent
+    and 1.0 is fully opaque.
+*/
+
+/*!
+    \since 4.7
+
+    \enum QPainter::PixmapFragmentHint
+
+    \value OpaqueHint Indicates that the pixmap fragments to be drawn are
+    opaque. Opaque fragments are potentially faster to draw.
+
+    \sa QPainter::drawPixmapFragments(), QPainter::PixmapFragment
+*/
+
 void qt_draw_helper(QPainterPrivate *p, const QPainterPath &path, QPainterPrivate::DrawOperation operation)
 {