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

Timestamp:

Feb 11, 2010, 11:19:06 PM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

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

trunk/src/gui/painting/qpainter.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information ([email protected])
+** All rights reserved.
+** Contact: Nokia Corporation ([email protected])
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -21 +22 @@
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you 
+** @nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -76 +76 @@
 #define QPaintEngine_OpaqueBackground 0x40000000
 
-// use the same rounding as in qrasterizer.cpp (6 bit fixed point)
-static const qreal aliasedCoordinateDelta = 0.5 - 0.015625;
-
 // #define QT_DEBUG_DRAW
 #ifdef QT_DEBUG_DRAW
@@ -166 +163 @@
 {
     Q_ASSERT(extended);
+
+
+
     bool doEmulation = false;
     if (state->bgMode == Qt::OpaqueMode)
@@ -185 +185 @@
             extended->setState(state);
         }
-    } else if (emulationEngine && emulationEngine != extended) {
+    } else if (emulationEngine = extended) {
         extended = emulationEngine->real_engine;
     }
@@ -260 +260 @@
         sp->d_ptr->d_ptrs_size = 4;
         sp->d_ptr->d_ptrs = (QPainterPrivate **)malloc(4 * sizeof(QPainterPrivate *));
+
     } else if (sp->d_ptr->refcount - 1 == sp->d_ptr->d_ptrs_size) {
         // However, to support corner cases we grow the array dynamically if needed.
         sp->d_ptr->d_ptrs_size <<= 1;
         const int newSize = sp->d_ptr->d_ptrs_size * sizeof(QPainterPrivate *);
-        sp->d_ptr->d_ptrs = (QPainterPrivate **)realloc(sp->d_ptr->d_ptrs, newSize);
-    }
-    sp->d_ptr->d_ptrs[++sp->d_ptr->refcount - 2] = q->d_ptr;
-    q->d_ptr = sp->d_ptr;
+        sp->d_ptr->d_ptrs = q_check_ptr((QPainterPrivate **)realloc(sp->d_ptr->d_ptrs, newSize));
+    }
+    sp->d_ptr->d_ptrs[++sp->d_ptr->refcount - 2] = q->d_ptr.data();
+    q->d_ptr.take();
+    q->d_ptr.reset(sp->d_ptr.data());
 
     Q_ASSERT(q->d_ptr->state);
@@ -282 +284 @@
 
     // Update matrix.
-    if (q->d_ptr->state->WxF)
-        q->d_ptr->state->worldMatrix.translate(-offset.x(), -offset.y());
-    else
-        q->d_ptr->state->redirection_offset = offset;
+    if (q->d_ptr->state->WxF) {
+        q->d_ptr->state->redirectionMatrix = q->d_ptr->state->matrix;
+        q->d_ptr->state->redirectionMatrix.translate(-offset.x(), -offset.y());
+        q->d_ptr->state->worldMatrix = QTransform();
+        q->d_ptr->state->WxF = false;
+    } else {
+        q->d_ptr->state->redirectionMatrix = QTransform::fromTranslate(-offset.x(), -offset.y());
+    }
     q->d_ptr->updateMatrix();
 
@@ -316 +322 @@
     d_ptrs[refcount - 1] = 0;
     q->restore();
-    q->d_ptr = original;
+    q->d_ptr.take();
+    q->d_ptr.reset(original);
 
     if (emulationEngine) {
@@ -411 +418 @@
             QTransform old_invMatrix = invMatrix;
             txinv = true;
-            invMatrix = QTransform().translate(-state->redirection_offset.x(), -state->redirection_offset.y());
+            invMatrix = QTransform();
             QPainterPath clipPath = q->clipPath();
             QRectF r = clipPath.boundingRect().intersected(absPathRect);
@@ -469 +476 @@
 
     q->save();
-    q->resetMatrix();
+    state->matrix = QTransform();
+    state->dirtyFlags |= QPaintEngine::DirtyTransform;
     updateState(state);
     engine->drawImage(absPathRect,
@@ -635 +643 @@
 
     txinv = false;                                // no inverted matrix
-    if (!state->redirection_offset.isNull()) {
-        // We want to translate in dev space so we do the adding of the redirection
-        // offset manually.
-        if (state->matrix.isAffine()) {
-            state->matrix = QTransform(state->matrix.m11(), state->matrix.m12(),
-                                       state->matrix.m21(), state->matrix.m22(),
-                                       state->matrix.dx()-state->redirection_offset.x(),
-                                       state->matrix.dy()-state->redirection_offset.y());
-        } else {
-            QTransform temp;
-            temp.translate(-state->redirection_offset.x(), -state->redirection_offset.y());
-            state->matrix *= temp;
-        }
-    }
+    state->matrix *= state->redirectionMatrix;
     if (extended)
         extended->transformChanged();
@@ -663 +658 @@
     Q_ASSERT(txinv == false);
     txinv = true;                                // creating inverted matrix
-    QTransform m;
-
-    if (state->VxF)
-        m = viewTransform();
-
-    if (state->WxF) {
-        if (state->VxF)
-            m = state->worldMatrix * m;
-        else
-            m = state->worldMatrix;
-    }
-    invMatrix = m.inverted();                // invert matrix
+    invMatrix = state->matrix.inverted();
 }
 
@@ -945 +929 @@
     other paint devices.
 
-    \ingroup multimedia
-    \mainclass
+    \ingroup 
+
     \reentrant
 
@@ -1026 +1010 @@
        the origin of widget's background.
 
-    \o viewport(), window(), worldMatrix() make up the painter's coordinate
+    \o viewport(), window(), world() make up the painter's coordinate
         transformation system. For more information, see the \l
         {Coordinate Transformations} section and the \l {The Coordinate
@@ -1037 +1021 @@
        painter when drawing text.
 
-    \o matrixEnabled() tells whether world transformation is enabled.
+    \o atrixEnabled() tells whether world transformation is enabled.
 
     \o viewTransformEnabled() tells whether view transformation is
@@ -1233 +1217 @@
 
     All the tranformation operations operate on the transformation
-    worldMatrix(). A matrix transforms a point in the plane to another
+    world(). 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 QMatrix documentation.
-
-    The setWorldMatrix() function can replace or add to the currently
-    set worldMatrix(). The resetMatrix() function resets any
+    the \l {The Coordinate System} and Q documentation.
+
+    The setWorld() function can replace or add to the currently
+    set world() function resets any
     transformations that were made using translate(), scale(),
-    shear(), rotate(), setWorldMatrix(), setViewport() and setWindow()
-    functions. The deviceMatrix() returns the matrix that transforms
+    shear(), rotate(), setWorld(), setViewport() and setWindow()
+    functions. The device() returns the matrix that transforms
     from logical coordinates to device coordinates of the platform
     dependent paint device. The latter function is only needed when
@@ -1250 +1234 @@
     coordinates which then are converted into the physical coordinates
     of the paint device. The mapping of the logical coordinates to the
-    physical coordinates are handled by QPainter's combinedMatrix(), a
-    combination of viewport() and window() and worldMatrix().  The
+    physical coordinates are handled by QPainter's combined(), a
+    combination of viewport() and window() and world The
     viewport() represents the physical coordinates specifying an
     arbitrary rectangle, the window() describes the same rectangle in
-    logical coordinates, and the worldMatrix() is identical with the
+    logical coordinates, and the world() is identical with the
     transformation matrix.
 
@@ -1334 +1318 @@
     polygons instead.
 
-    \sa QPaintDevice, QPaintEngine, {QtSvg Module}, {Basic Drawing Example}
+    \section1 Performance
+
+    QPainter is a rich framework that allows developers to do a great
+    variety of graphical operations, such as gradients, composition
+    modes and vector graphics. And QPainter can do this across a
+    variety of different hardware and software stacks. Naturally the
+    underlying combination of hardware and software has some
+    implications for performance, and ensuring that every single
+    operation is fast in combination with all the various combinations
+    of composition modes, brushes, clipping, transformation, etc, is
+    close to an impossible task because of the number of
+    permutations. As a compromise we have selected a subset of the
+    QPainter API and backends, were performance is guaranteed to be as
+    good as we can sensibly get it for the given combination of
+    hardware and software.
+
+    The backends we focus on as high-performance engines are:
+
+    \list
+
+    \o Raster - This backend implements all rendering in pure software
+    and is always used to render into QImages. For optimal performance
+    only use the format types QImage::Format_ARGB32_Premultiplied,
+    QImage::Format_RGB32 or QImage::Format_RGB16. Any other format,
+    including QImage::Format_ARGB32, has significantly worse
+    performance. This engine is also used by default on Windows and on
+    QWS. It can be used as default graphics system on any
+    OS/hardware/software combination by passing \c {-graphicssystem
+    raster} on the command line
+
+    \o OpenGL 2.0 (ES) - This backend is the primary backend for
+    hardware accelerated graphics. It can be run on desktop machines
+    and embedded devices supporting the OpenGL 2.0 or OpenGL/ES 2.0
+    specification. This includes most graphics chips produced in the
+    last couple of years. The engine can be enabled by using QPainter
+    onto a QGLWidget or by passing \c {-graphicssystem opengl} on the
+    command line when the underlying system supports it.
+
+    \o OpenVG - This backend implements the Khronos standard for 2D
+    and Vector Graphics. It is primarily for embedded devices with
+    hardware support for OpenVG.  The engine can be enabled by
+    passing \c {-graphicssystem openvg} on the command line when
+    the underlying system supports it.
+
+    \endlist
+
+    These operations are:
+
+    \list
+
+    \o Simple transformations, meaning translation and scaling, pluss
+    0, 90, 180, 270 degree rotations.
+
+    \o \c drawPixmap() in combination with simple transformations and
+    opacity with non-smooth transformation mode
+    (\c QPainter::SmoothPixmapTransform not enabled as a render hint).
+
+    \o Text drawing with regular font sizes with simple
+    transformations with solid colors using no or 8-bit antialiasing.
+
+    \o Rectangle fills with solid color, two-color linear gradients
+    and simple transforms.
+
+    \o Rectangular clipping with simple transformations and intersect
+    clip.
+
+    \o Composition Modes \c QPainter::CompositionMode_Source and
+    QPainter::CompositionMode_SourceOver
+
+    \o Rounded rectangle filling using solid color and two-color
+    linear gradients fills.
+
+    \o 3x3 patched pixmaps, via qDrawBorderPixmap.
+
+    \endlist
+
+    This list gives an indication of which features to safely use in
+    an application where performance is critical. For certain setups,
+    other operations may be fast too, but before making extensive use
+    of them, it is recommended to benchmark and verify them on the
+    system where the software will run in the end. There are also
+    cases where expensive operations are ok to use, for instance when
+    the result is cached in a QPixmap.
+
+    \sa QPaintDevice, QPaintEngine, {QtSvg Module}, {Basic Drawing Example},
+        {Drawing Utility Functions}
 */
 
@@ -1375 +1444 @@
 
 QPainter::QPainter()
-{
-    d_ptr = new QPainterPrivate(this);
+    : d_ptr(new QPainterPrivate(this))
+{
 }
 
@@ -1408 +1477 @@
     Q_ASSERT(pd != 0);
     if (!QPainterPrivate::attachPainterPrivate(this, pd)) {
-        d_ptr = new QPainterPrivate(this);
+        d_ptr);
         begin(pd);
     }
@@ -1420 +1489 @@
 {
     d_ptr->inDestructor = true;
-    if (isActive())
-        end();
-    else if (d_ptr->refcount > 1)
-        d_ptr->detachPainterPrivate(this);
-
+    QT_TRY {
+        if (isActive())
+            end();
+        else if (d_ptr->refcount > 1)
+            d_ptr->detachPainterPrivate(this);
+    } QT_CATCH(...) {
+        // don't throw anything in the destructor.
+    }
     if (d_ptr) {
         // Make sure we haven't messed things up.
@@ -1432 +1504 @@
         if (d_ptr->d_ptrs)
             free(d_ptr->d_ptrs);
-        delete d_ptr;
     }
 }
@@ -1485 +1556 @@
     d->state->deviceFont = QFont(widget->font(), const_cast<QWidget*> (widget));
     d->state->font = d->state->deviceFont;
-    if (d->engine) {
+    if (d->extended) {
+        d->extended->penChanged();
+    } else if (d->engine) {
         d->engine->setDirty(QPaintEngine::DirtyPen);
         d->engine->setDirty(QPaintEngine::DirtyBrush);
@@ -1571 +1644 @@
         for (int i=0; i<d->state->clipInfo.size(); ++i) {
             const QPainterClipInfo &info = d->state->clipInfo.at(i);
-            tmp->matrix.setMatrix(info.matrix.m11(), info.matrix.m12(), info.matrix.m13(),
-                                  info.matrix.m21(), info.matrix.m22(), info.matrix.m23(),
-                                  info.matrix.dx() - d->state->redirection_offset.x(),
-                                  info.matrix.dy() - d->state->redirection_offset.y(), info.matrix.m33());
+            tmp->matrix = info.matrix;
+            tmp->matrix *= d->state->redirectionMatrix;
             tmp->clipOperation = info.operation;
             if (info.clipType == QPainterClipInfo::RectClip) {
@@ -1622 +1693 @@
     time.
 
+
+
+
     \sa end(), QPainter()
 */
+
+
+
+
+
+
+
+
+
 
 bool QPainter::begin(QPaintDevice *pd)
@@ -1670 +1753 @@
 #endif
 
-
-    d->device = pd;
     if (pd->devType() == QInternal::Pixmap)
         static_cast<QPixmap *>(pd)->detach();
@@ -1678 +1759 @@
 
     d->engine = pd->paintEngine();
-    d->extended = d->engine && d->engine->isExtended() ? static_cast<QPaintEngineEx *>(d->engine) : 0;
+
+    if (!d->engine) {
+        qWarning("QPainter::begin: Paint device returned engine == 0, type: %d", pd->devType());
+        return false;
+    }
+
+    d->device = pd;
+
+    d->extended = d->engine->isExtended() ? static_cast<QPaintEngineEx *>(d->engine) : 0;
     if (d->emulationEngine)
         d->emulationEngine->real_engine = d->extended;
@@ -1688 +1777 @@
     d->states.push_back(d->state);
 
-    d->state->redirection_offset = redirectionOffset;
+    d->state->redirection;
     d->state->brushOrigin = QPointF();
-
-    if (!d->engine) {
-        qWarning("QPainter::begin: Paint device returned engine == 0, type: %d", pd->devType());
-        return true;
-    }
 
     // Slip a painter state into the engine before we do any other operations
@@ -1714 +1798 @@
                 qWarning("QPainter::begin: Widget painting can only begin as a "
                          "result of a paintEvent");
-                d->engine = 0;
-                d->device = 0;
+                qt_cleanup_painter_state(d);
                 return false;
             }
@@ -1722 +1805 @@
             if (!inPaintEvent && paintOutsidePaintEvent && !widget->internalWinId()
                 && widget->testAttribute(Qt::WA_WState_Created)) {
-                d->state->redirection_offset -= widget->mapTo(widget->nativeParentWidget(), QPoint());
+                const QPoint offset = widget->mapTo(widget->nativeParentWidget(), QPoint());
+                d->state->redirectionMatrix.translate(offset.x(), offset.y());
             }
             break;
@@ -1732 +1816 @@
             if (pm->isNull()) {
                 qWarning("QPainter::begin: Cannot paint on a null pixmap");
-                d->engine = 0;
-                d->device = 0;
+                qt_cleanup_painter_state(d);
                 return false;
             }
@@ -1749 +1832 @@
             if (img->isNull()) {
                 qWarning("QPainter::begin: Cannot paint on a null image");
-                d->engine = 0;
-                d->device = 0;
+                qt_cleanup_painter_state(d);
+                return false;
+            } else if (img->format() == QImage::Format_Indexed8) {
+                // Painting on indexed8 images is not supported.
+                qWarning("QPainter::begin: Cannot paint on an image with the QImage::Format_Indexed8 format");
+                qt_cleanup_painter_state(d);
                 return false;
             }
@@ -1773 +1860 @@
             end();
         } else {
-            d->states.clear();
-            delete d->state;
-            d->state = 0;
+            qt_cleanup_painter_state(d);
         }
-        d->engine = 0;
-        d->device = 0;
         return false;
     } else {
@@ -1804 +1887 @@
     }
 
-    d->state->redirection_offset += d->engine->coordinateOffset();
+    const QPoint coordinateOffset = d->engine->coordinateOffset();
+    d->state->redirectionMatrix.translate(-coordinateOffset.x(), -coordinateOffset.y());
 
     Q_ASSERT(d->engine->isActive());
 
-    if (!d->state->redirection_offset.isNull())
+    if (!d->state->redirection())
         d->updateMatrix();
 
@@ -1840 +1924 @@
     if (!d->engine) {
         qWarning("QPainter::end: Painter not active, aborted");
-        d->states.clear();
-        delete d->state;
-        d->state = 0;
-        d->device = 0;
+        qt_cleanup_painter_state(d);
         return false;
     }
@@ -1850 +1931 @@
         d->detachPainterPrivate(this);
         return true;
-    }
-
-    if (d->states.size() > 1) {
-        qWarning("QPainter::end: Painter ended with %d saved states",
-                 d->states.size());
     }
 
@@ -1870 +1946 @@
     }
 
+
+
+
+
+
     if (d->engine->autoDestruct()) {
         delete d->engine;
     }
-
-    d->engine = 0;
 
     if (d->emulationEngine) {
@@ -1885 +1964 @@
     }
 
-    d->states.clear();
-    delete d->state;
-    d->state = 0;
-
-    d->device = 0;
+    qt_cleanup_painter_state(d);
+
     return ended;
 }
@@ -1906 +1982 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 /*!
@@ -2015 +2139 @@
 
     The brush origin specifies the (0, 0) coordinate of the painter's
-    brush. This setting only applies to pattern brushes and pixmap
-    brushes.
+    brush.
 
     Note that while the brushOrigin() was necessary to adopt the
@@ -2237 +2360 @@
     Sets the composition mode to the given \a mode.
 
-    \warning You can only set the composition mode for QPainter
-    objects that operates on a QImage.
+    \warning Only a QPainter operating on a QImage fully supports all
+    composition modes. The RasterOp modes are supported for X11 as
+    described in compositionMode().
 
     \sa compositionMode()
@@ -2372 +2496 @@
     is given in logical coordinates.
 
+
+
+
+
+
     \sa setClipRegion(), clipPath(), setClipping()
 */
@@ -2392 +2521 @@
     for (int i=0; i<d->state->clipInfo.size(); ++i) {
         const QPainterClipInfo &info = d->state->clipInfo.at(i);
-        QRegion other;
         switch (info.clipType) {
 
@@ -2445 +2573 @@
                 continue;
             }
-            if (info.operation == Qt::IntersectClip)
-                region &= QRegion(info.rect) * matrix;
-            else if (info.operation == Qt::UniteClip)
+            if (info.operation == Qt::IntersectClip) {
+                // Use rect intersection if possible.
+                if (matrix.type() <= QTransform::TxScale)
+                    region &= matrix.mapRect(info.rect);
+                else
+                    region &= matrix.map(QRegion(info.rect));
+            } else if (info.operation == Qt::UniteClip) {
                 region |= QRegion(info.rect) * matrix;
-            else if (info.operation == Qt::NoClip) {
+            else if (info.operation == Qt::NoClip) {
                 lastWasNothing = true;
                 region = QRegion();
-            } else
+            } else
                 region = QRegion(info.rect) * matrix;
+
             break;
         }
@@ -2464 +2597 @@
                 continue;
             }
-            if (info.operation == Qt::IntersectClip)
-                region &= QRegion(info.rectf.toRect()) * matrix;
-            else if (info.operation == Qt::UniteClip)
+            if (info.operation == Qt::IntersectClip) {
+                // Use rect intersection if possible.
+                if (matrix.type() <= QTransform::TxScale)
+                    region &= matrix.mapRect(info.rectf.toRect());
+                else
+                    region &= matrix.map(QRegion(info.rectf.toRect()));
+            } else if (info.operation == Qt::UniteClip) {
                 region |= QRegion(info.rectf.toRect()) * matrix;
-            else if (info.operation == Qt::NoClip) {
+            else if (info.operation == Qt::NoClip) {
                 lastWasNothing = true;
                 region = QRegion();
-            } else
+            } else
                 region = QRegion(info.rectf.toRect()) * matrix;
+
             break;
         }
@@ -2486 +2624 @@
     Returns the currently clip as a path. Note that the clip path is
     given in logical coordinates.
+
+
+
+
+
 
     \sa setClipPath(), clipRegion(), setClipping()
@@ -2545 +2688 @@
 
     if (d->extended) {
+
+
+
         if (!d->engine) {
             qWarning("QPainter::setClipRect: Painter not active");
@@ -2558 +2704 @@
         d->state->clipEnabled = true;
         d->extended->clip(vp, op);
-        d->state->clipInfo << QPainterClipInfo(rect, op, combinedTransform());
+        if (op == Qt::ReplaceClip || op == Qt::NoClip)
+            d->state->clipInfo.clear();
+        d->state->clipInfo << QPainterClipInfo(rect, op, d->state->matrix);
         d->state->clipOperation = op;
         return;
@@ -2598 +2746 @@
     }
 
+
+
+
     if (d->extended) {
         d->state->clipEnabled = true;
         d->extended->clip(rect, op);
-        d->state->clipInfo << QPainterClipInfo(rect, op, combinedTransform());
+        if (op == Qt::ReplaceClip || op == Qt::NoClip)
+            d->state->clipInfo.clear();
+        d->state->clipInfo << QPainterClipInfo(rect, op, d->state->matrix);
         d->state->clipOperation = op;
         return;
     }
-
-    if (!hasClipping() && (op == Qt::IntersectClip || op == Qt::UniteClip))
-        op = Qt::ReplaceClip;
 
     d->state->clipRegion = rect;
@@ -2613 +2763 @@
     if (op == Qt::NoClip || op == Qt::ReplaceClip)
         d->state->clipInfo.clear();
-    d->state->clipInfo << QPainterClipInfo(rect, op, combinedTransform());
+    d->state->clipInfo << QPainterClipInfo(rect, op, );
     d->state->clipEnabled = true;
     d->state->dirtyFlags |= QPaintEngine::DirtyClipRegion | QPaintEngine::DirtyClipEnabled;
@@ -2651 +2801 @@
     }
 
+
+
+
     if (d->extended) {
         d->state->clipEnabled = true;
         d->extended->clip(r, op);
-        d->state->clipInfo << QPainterClipInfo(r, op, combinedTransform());
+        if (op == Qt::NoClip || op == Qt::ReplaceClip)
+            d->state->clipInfo.clear();
+        d->state->clipInfo << QPainterClipInfo(r, op, d->state->matrix);
         d->state->clipOperation = op;
         return;
     }
-
-    if (!hasClipping() && (op == Qt::IntersectClip || op == Qt::UniteClip))
-        op = Qt::ReplaceClip;
 
     d->state->clipRegion = r;
@@ -2666 +2818 @@
     if (op == Qt::NoClip || op == Qt::ReplaceClip)
         d->state->clipInfo.clear();
-    d->state->clipInfo << QPainterClipInfo(r, op, combinedTransform());
+    d->state->clipInfo << QPainterClipInfo(r, op, );
     d->state->clipEnabled = true;
     d->state->dirtyFlags |= QPaintEngine::DirtyClipRegion | QPaintEngine::DirtyClipEnabled;
@@ -2674 +2826 @@
 /*!
     \since 4.2
+
 
     Sets the transformation matrix to \a matrix and enables transformations.
@@ -2712 +2865 @@
     documentation.
 
-    \sa worldMatrixEnabled(), QMatrix
+    \sa 
 */
 
@@ -2722 +2875 @@
 /*!
     \since 4.2
+
 
     Returns the world transformation matrix.
@@ -2771 +2925 @@
 /*!
     \since 4.2
+
 
     Returns the transformation matrix combining the current
@@ -2778 +2933 @@
     function to preserve the properties of perspective transformations.
 
-    \sa setWorldMatrix(), setWindow(), setViewport()
+    \sa setWorld(), setWindow(), setViewport()
 */
 QMatrix QPainter::combinedMatrix() const
@@ -2787 +2942 @@
 
 /*!
+
+
     Returns the matrix that transforms from logical coordinates to
     device coordinates of the platform dependent paint device.
@@ -2814 +2971 @@
 
 /*!
+
+
     Resets any transformations that were made using translate(), scale(),
     shear(), rotate(), setWorldMatrix(), setViewport() and
@@ -2838 +2997 @@
     matrix is not changed.
 
-    \sa worldMatrixEnabled(), worldMatrix(), {QPainter#Coordinate
+    \sa worldMatrixEnabled(), world(), {QPainter#Coordinate
     Transformations}{Coordinate Transformations}
 */
@@ -2867 +3026 @@
     false.
 
-    \sa setWorldMatrixEnabled(), worldMatrix(), {The Coordinate System}
+    \sa setWorldMatrixEnabled(), world(), {The Coordinate System}
 */
 
@@ -2909 +3068 @@
     Scales the coordinate system by (\a{sx}, \a{sy}).
 
-    \sa setWorldMatrix() {QPainter#Coordinate Transformations}{Coordinate
+    \sa setWorld() {QPainter#Coordinate Transformations}{Coordinate
     Transformations}
 */
@@ -2933 +3092 @@
     Shears the coordinate system by (\a{sh}, \a{sv}).
 
-    \sa setWorldMatrix(), {QPainter#Coordinate Transformations}{Coordinate
+    \sa setWorld(), {QPainter#Coordinate Transformations}{Coordinate
     Transformations}
 */
@@ -2959 +3118 @@
     Rotates the coordinate system the given \a angle clockwise.
 
-    \sa setWorldMatrix(), {QPainter#Coordinate Transformations}{Coordinate
+    \sa setWorld(), {QPainter#Coordinate Transformations}{Coordinate
     Transformations}
 */
@@ -2984 +3143 @@
     given \a offset is added to points.
 
-    \sa setWorldMatrix(), {QPainter#Coordinate Transformations}{Coordinate
+    \sa setWorld(), {QPainter#Coordinate Transformations}{Coordinate
     Transformations}
 */
@@ -3048 +3207 @@
     }
 
+
+
+
     if (d->extended) {
         d->state->clipEnabled = true;
         d->extended->clip(path, op);
-        d->state->clipInfo << QPainterClipInfo(path, op, combinedTransform());
+        if (op == Qt::NoClip || op == Qt::ReplaceClip)
+            d->state->clipInfo.clear();
+        d->state->clipInfo << QPainterClipInfo(path, op, d->state->matrix);
         d->state->clipOperation = op;
         return;
     }
-
-
-
-    if (!hasClipping() && (op == Qt::IntersectClip || op == Qt::UniteClip))
-        op = Qt::ReplaceClip;
 
     d->state->clipPath = path;
@@ -3065 +3224 @@
     if (op == Qt::NoClip || op == Qt::ReplaceClip)
         d->state->clipInfo.clear();
-    d->state->clipInfo << QPainterClipInfo(path, op, combinedTransform());
+    d->state->clipInfo << QPainterClipInfo(path, op, );
     d->state->clipEnabled = true;
     d->state->dirtyFlags |= QPaintEngine::DirtyClipPath | QPaintEngine::DirtyClipEnabled;
@@ -3713 +3872 @@
         return;
 
+
+
     if (d->extended) {
-        d->state->pen = pen;
         d->checkEmulation();
         d->extended->penChanged();
@@ -3720 +3880 @@
     }
 
-    // Do some checks to see if we are the same pen.
-    Qt::PenStyle currentStyle = d->state->pen.style();
-    if (currentStyle == pen.style() && currentStyle != Qt::CustomDashLine) {
-        if (currentStyle == Qt::NoPen ||
-            (d->state->pen.isSolid() && pen.isSolid()
-             && d->state->pen.color() == pen.color()
-             && d->state->pen.widthF() == pen.widthF()
-             && d->state->pen.capStyle() == pen.capStyle()
-             && d->state->pen.joinStyle() == pen.joinStyle()
-             && d->state->pen.isCosmetic() == pen.isCosmetic()))
-            return;
-    }
-
-    d->state->pen = pen;
     d->state->dirtyFlags |= QPaintEngine::DirtyPen;
 }
@@ -3816 +3962 @@
     }
 
-    Qt::BrushStyle currentStyle = d->state->brush.style();
-    if (currentStyle == brush.style()) {
-        if (currentStyle == Qt::NoBrush
-            || (currentStyle == Qt::SolidPattern
-                && d->state->brush.color() == brush.color()))
-            return;
-    }
-
     d->state->brush = brush;
     d->state->dirtyFlags |= QPaintEngine::DirtyBrush;
@@ -3971 +4109 @@
     \sa drawRect(), QPen
 */
-// FALCON: Should we add a specialized method in QPaintEngineEx?
 void QPainter::drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode)
 {
@@ -3989 +4126 @@
 
     if (d->extended) {
-        QPainterPath::ElementType types[] = {
-            QPainterPath::MoveToElement,
-            QPainterPath::LineToElement,
-            QPainterPath::CurveToElement,
-            QPainterPath::CurveToDataElement,
-            QPainterPath::CurveToDataElement,
-            QPainterPath::LineToElement,
-            QPainterPath::CurveToElement,
-            QPainterPath::CurveToDataElement,
-            QPainterPath::CurveToDataElement,
-            QPainterPath::LineToElement,
-            QPainterPath::CurveToElement,
-            QPainterPath::CurveToDataElement,
-            QPainterPath::CurveToDataElement,
-            QPainterPath::LineToElement,
-            QPainterPath::CurveToElement,
-            QPainterPath::CurveToDataElement,
-            QPainterPath::CurveToDataElement
-        };
-
-        qreal x1 = rect.left();
-        qreal x2 = rect.right();
-        qreal y1 = rect.top();
-        qreal y2 = rect.bottom();
-
-        if (mode == Qt::RelativeSize) {
-            xRadius = xRadius * rect.width() / 200.;
-            yRadius = yRadius * rect.height() / 200.;
-        }
-
-        xRadius = qMin(xRadius, rect.width() / 2);
-        yRadius = qMin(yRadius, rect.height() / 2);
-
-        qreal pts[] = {
-            x1 + xRadius, y1,                   // MoveTo
-            x2 - xRadius, y1,                   // LineTo
-            x2 - (1 - KAPPA) * xRadius, y1,     // CurveTo
-            x2, y1 + (1 - KAPPA) * yRadius,
-            x2, y1 + yRadius,
-            x2, y2 - yRadius,                   // LineTo
-            x2, y2 - (1 - KAPPA) * yRadius,     // CurveTo
-            x2 - (1 - KAPPA) * xRadius, y2,
-            x2 - xRadius, y2,
-            x1 + xRadius, y2,                   // LineTo
-            x1 + (1 - KAPPA) * xRadius, y2,           // CurveTo
-            x1, y2 - (1 - KAPPA) * yRadius,
-            x1, y2 - yRadius,
-            x1, y1 + yRadius,                   // LineTo
-            x1, y1 + KAPPA * yRadius,           // CurveTo
-            x1 + (1 - KAPPA) * xRadius, y1,
-            x1 + xRadius, y1
-        };
-
-        QVectorPath path(pts, 17, types);
-        d->extended->draw(path);
+        d->extended->drawRoundedRect(rect, xRadius, yRadius, mode);
         return;
     }
@@ -4085 +4168 @@
 void QPainter::drawRoundRect(const QRectF &r, int xRnd, int yRnd)
 {
-#ifdef QT_DEBUG_DRAW
-    if (qt_show_painter_debug_output)
-        printf("QPainter::drawRoundRectangle(), [%.2f,%.2f,%.2f,%.2f]\n", r.x(), r.y(), r.width(), r.height());
-#endif
-    Q_D(QPainter);
-
-    if (!d->engine)
-        return;
-
-    if(xRnd <= 0 || yRnd <= 0) {             // draw normal rectangle
-        drawRect(r);
-        return;
-    }
-
-    QPainterPath path;
-    path.addRoundRect(r, xRnd, yRnd);
-    drawPath(path);
+    drawRoundedRect(r, xRnd, yRnd, Qt::RelativeSize);
 }
 
@@ -5122 +5189 @@
 }
 
+
+
+
+
+
 /*!
     \fn void QPainter::drawPixmap(const QRectF &target, const QPixmap &pixmap, const QRectF &source)
@@ -5174 +5246 @@
     int h = pm.height();
 
+
+
+
     // Emulate opaque background for bitmaps
     if (d->state->bgMode == Qt::OpaqueMode && pm.isQBitmap()) {
@@ -5187 +5262 @@
     {
         save();
-        // If there is no scaling or transformation involved we have to make sure we use the
+        // If there is no ation involved we have to make sure we use the
         // antialiased and not the aliased coordinate system by rounding the coordinates.
-        if (d->state->matrix.type() <= QTransform::TxTranslate) {
-            x = qRound(x + d->state->matrix.dx()) - d->state->matrix.dx();
-            y = qRound(y + d->state->matrix.dy()) - d->state->matrix.dy();
+        if (d->state->matrix.type() <= QTransform::TxScale) {
+            const QPointF p = roundInDeviceCoordinates(QPointF(x, y), d->state->matrix);
+            x = p.x();
+            y = p.y();
         }
         translate(x, y);
@@ -5301 +5377 @@
     {
         save();
-        // If there is no scaling or transformation involved we have to make sure we use the
+        // If there is no ation involved we have to make sure we use the
         // antialiased and not the aliased coordinate system by rounding the coordinates.
+
+
+
+
+
+
         if (d->state->matrix.type() <= QTransform::TxTranslate && sw == w && sh == h) {
-            x = qRound(x + d->state->matrix.dx()) - d->state->matrix.dx();
-            y = qRound(y + d->state->matrix.dy()) - d->state->matrix.dy();
             sx = qRound(sx);
             sy = qRound(sy);
@@ -5311 +5391 @@
             sh = qRound(sh);
         }
+
         translate(x, y);
         scale(w / sw, h / sh);
@@ -5460 +5541 @@
     {
         save();
-        // If there is no scaling or transformation involved we have to make sure we use the
+        // If there is no ation involved we have to make sure we use the
         // antialiased and not the aliased coordinate system by rounding the coordinates.
-        if (d->state->matrix.type() <= QTransform::TxTranslate) {
-            x = qRound(x + d->state->matrix.dx()) - d->state->matrix.dx();
-            y = qRound(y + d->state->matrix.dy()) - d->state->matrix.dy();
+        if (d->state->matrix.type() <= QTransform::TxScale) {
+            const QPointF p = roundInDeviceCoordinates(QPointF(x, y), d->state->matrix);
+            x = p.x();
+            y = p.y();
         }
         translate(x, y);
@@ -5563 +5645 @@
     {
         save();
-        // If there is no scaling or transformation involved we have to make sure we use the
+        // If there is no ation involved we have to make sure we use the
         // antialiased and not the aliased coordinate system by rounding the coordinates.
+
+
+
+
+
+
         if (d->state->matrix.type() <= QTransform::TxTranslate && sw == w && sh == h) {
-            x = qRound(x + d->state->matrix.dx()) - d->state->matrix.dx();
-            y = qRound(y + d->state->matrix.dy()) - d->state->matrix.dy();
             sx = qRound(sx);
             sy = qRound(sy);
@@ -5659 +5745 @@
     }
     QFixed x = QFixed::fromReal(p.x());
-    QFixed ox = x;
 
     for (int i = 0; i < nItems; ++i) {
@@ -5886 +5971 @@
 */
 
-/*! \internal
+/*!
+    \fn void QPainter::drawTextItem(const QPointF &p, const QTextItem &ti)
+
+    \internal
+    \since 4.1
+
     Draws the text item \a ti at position \a p.
 
@@ -5899 +5989 @@
     underlining and strikeout.
 */
-static QPainterPath generateWavyPath(qreal minWidth, qreal maxRadius, QPaintDevice *device)
-{
-    extern int qt_defaultDpi();
+
+static QPixmap generateWavyPixmap(qreal maxRadius, const QPen &pen)
+{
+    const qreal radiusBase = qMax(qreal(1), maxRadius);
+
+    QString key = QLatin1String("WaveUnderline-");
+    key += pen.color().name();
+    key += QLatin1Char('-');
+    key += QString::number(radiusBase);
+
+    QPixmap pixmap;
+    if (QPixmapCache::find(key, pixmap))
+        return pixmap;
+
+    const qreal halfPeriod = qMax(qreal(2), qreal(radiusBase * 1.61803399)); // the golden ratio
+    const int width = qCeil(100 / (2 * halfPeriod)) * (2 * halfPeriod);
+    const int radius = qFloor(radiusBase);
+
     QPainterPath path;
 
-    bool up = true;
-    const qreal radius = qMax(qreal(.5), qMin(qreal(1.25 * device->logicalDpiY() / qt_defaultDpi()), maxRadius));
-    qreal xs, ys;
-    int i = 0;
-    path.moveTo(0, radius);
-    do {
-        xs = i*(2*radius);
-        ys = 0;
-
-        qreal remaining = minWidth - xs;
-        qreal angle = 180;
-
-        // cut-off at the last arc segment
-        if (remaining < 2 * radius)
-            angle = 180 * remaining / (2 * radius);
-
-        path.arcTo(xs, ys, 2*radius, 2*radius, 180, up ? angle : -angle);
-
-        up = !up;
-        ++i;
-    } while (xs + 2*radius < minWidth);
-
-    return path;
+    qreal xs = 0;
+    qreal ys = radius;
+
+    while (xs < width) {
+        xs += halfPeriod;
+        ys = -ys;
+        path.quadTo(xs - halfPeriod / 2, ys, xs, 0);
+    }
+
+    pixmap = QPixmap(width, radius * 2);
+    pixmap.fill(Qt::transparent);
+    {
+        QPen wavePen = pen;
+        wavePen.setCapStyle(Qt::SquareCap);
+
+        // This is to protect against making the line too fat, as happens on Mac OS X
+        // due to it having a rather thick width for the regular underline.
+        const qreal maxPenWidth = .8 * radius;
+        if (wavePen.widthF() > maxPenWidth)
+            wavePen.setWidth(maxPenWidth);
+
+        QPainter imgPainter(&pixmap);
+        imgPainter.setPen(wavePen);
+        imgPainter.setRenderHint(QPainter::Antialiasing);
+        imgPainter.translate(0, radius);
+        imgPainter.drawPath(path);
+    }
+
+    QPixmapCache::insert(key, pixmap);
+
+    return pixmap;
 }
 
@@ -5947 +6060 @@
 
     QLineF line(pos.x(), pos.y(), pos.x() + ti.width.toReal(), pos.y());
+
+
     // deliberately ceil the offset to avoid the underline coming too close to
     // the text above it.
-    const qreal underlinePos = pos.y() + qCeil(fe->underlinePosition().toReal());
+    const qreal underlinePos = pos.y() + qCeil();
 
     if (underlineStyle == QTextCharFormat::SpellCheckUnderline) {
@@ -5957 +6072 @@
     if (underlineStyle == QTextCharFormat::WaveUnderline) {
         painter->save();
-        painter->setRenderHint(QPainter::Antialiasing);
-        painter->translate(pos.x(), underlinePos);
+        painter->translate(0, pos.y() + 1);
 
         QColor uc = ti.charFormat.underlineColor();
         if (uc.isValid())
-            painter->setPen(uc);
-
-        painter->drawPath(generateWavyPath(ti.width.toReal(),
-                                           fe->underlinePosition().toReal(),
-                                           painter->device()));
+            pen.setColor(uc);
+
+        // 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();
+
+        painter->setBrushOrigin(painter->brushOrigin().x(), 0);
+        painter->fillRect(pos.x(), 0, qCeil(ti.width.toReal()), qMin(wave.height(), descent), wave);
         painter->restore();
     } else if (underlineStyle != QTextCharFormat::NoUnderline) {
@@ -6001 +6118 @@
 }
 
-/*!
-    \internal
-    \since 4.1
-*/
 void QPainter::drawTextItem(const QPointF &p, const QTextItem &_ti)
 {
@@ -6043 +6156 @@
         if (d->state->matrix.type() < QTransform::TxShear) {
             bool isPlain90DegreeRotation =
-                (qFuzzyCompare(m.m11() + 1, qreal(1))
-                 && qFuzzyCompare(m.m12(), qreal(1))
-                 && qFuzzyCompare(m.m21(), qreal(-1))
-                 && qFuzzyCompare(m.m22() + 1, qreal(1))
+                (qFuzzy))
+                 && qFuzzy qreal(1))
+                 && qFuzzy1))
+                 && qFuzzy))
                     )
                 ||
-                (qFuzzyCompare(m.m11(), qreal(-1))
-                 && qFuzzyCompare(m.m12() + 1, qreal(1))
-                 && qFuzzyCompare(m.m21() + 1, qreal(1))
-                 && qFuzzyCompare(m.m22(), qreal(-1))
+                (qFuzzy1))
+                 && qFuzzy))
+                 && qFuzzy))
+                 && qFuzzy1))
                     )
                 ||
-                (qFuzzyCompare(m.m11() + 1, qreal(1))
-                 && qFuzzyCompare(m.m12(), qreal(-1))
-                 && qFuzzyCompare(m.m21(), qreal(1))
-                 && qFuzzyCompare(m.m22() + 1, qreal(1))
+                (qFuzzy))
+                 && qFuzzy1))
+                 && qFuzzy qreal(1))
+                 && qFuzzy))
                     )
                 ;
@@ -6310 +6423 @@
         setPen(Qt::NoPen);
 
-        // If there is no scaling or transformation involved we have to make sure we use the
+        // If there is no ation involved we have to make sure we use the
         // antialiased and not the aliased coordinate system by rounding the coordinates.
-        if (d->state->matrix.type() <= QTransform::TxTranslate) {
-            qreal x = qRound(r.x() + d->state->matrix.dx()) - d->state->matrix.dx();
-            qreal y = qRound(r.y() + d->state->matrix.dy()) - d->state->matrix.dy();
-            qreal w = qRound(r.width());
-            qreal h = qRound(r.height());
-            sx = qRound(sx);
-            sy = qRound(sy);
+        if (d->state->matrix.type() <= QTransform::TxScale) {
+            const QPointF p = roundInDeviceCoordinates(r.topLeft(), d->state->matrix);
+
+            if (d->state->matrix.type() <= QTransform::TxTranslate) {
+                sx = qRound(sx);
+                sy = qRound(sy);
+            }
+
             setBrushOrigin(QPointF(r.x()-sx, r.y()-sy));
-            drawRect(QRectF(x, y, w, h));
+            drawRect(QRectF());
         } else {
             setBrushOrigin(QPointF(r.x()-sx, r.y()-sy));
@@ -6748 +6862 @@
     false.
 
-    \sa setViewTransformEnabled(), worldMatrix()
+    \sa setViewTransformEnabled(), world()
 */
 
@@ -6904 +7018 @@
     \compat
 
-    Use resetMatrix() instead.
+    Use reset() instead.
 */
 
@@ -6950 +7064 @@
 
 /*!
-    Use the worldMatrix() combined with QMatrix::dx() instead.
+    \obsolete
+
+    Use the worldTransform() combined with QTransform::dx() instead.
 
     \oldcode
@@ -6957 +7073 @@
     \newcode
         QPainter painter(this);
-        qreal x = painter.worldMatrix().dx();
+        qreal x = painter.world().dx();
     \endcode
 */
@@ -6971 +7087 @@
 
 /*!
-    Use the worldMatrix() combined with QMatrix::dy() instead.
+    \obsolete
+
+    Use the worldTransform() combined with QTransform::dy() instead.
 
     \oldcode
@@ -6978 +7096 @@
     \newcode
         QPainter painter(this);
-        qreal y = painter.worldMatrix().dy();
+        qreal y = painter.world().dy();
     \endcode
 */
@@ -7076 +7194 @@
     \newcode
         QPainter painter(this);
-        QPolygon transformed = polygon.mid(index, count) * painter.combinedMatrix();
+        QPolygon transformed = polygon.mid(index, count) * painter.combined();
     \endcode
 */
@@ -7091 +7209 @@
     \fn QPoint QPainter::xFormDev(const QPoint &point) const
     \overload
-
-    Use combinedTransform() combined with QMatrix::inverted() instead.
+    \obsolete
+
+    Use combinedTransform() combined with QTransform::inverted() instead.
 
     \oldcode
@@ -7099 +7218 @@
     \newcode
         QPainter painter(this);
-        QPoint transformed = point * painter.combinedMatrix().inverted();
+        QPoint transformed = point * painter.combined().inverted();
     \endcode
 */
@@ -7118 +7237 @@
     \fn QRect QPainter::xFormDev(const QRect &rectangle) const
     \overload
-
-    Use  combineMatrix() combined with QMatrix::inverted() instead.
+    \obsolete
+
+    Use combinedTransform() combined with QTransform::inverted() instead.
 
     \oldcode
@@ -7126 +7246 @@
     \newcode
         QPainter painter(this);
-        QRect transformed = rectangle * painter.combinedMatrix().inverted();
+        QRegion region = QRegion(rectangle) * painter.combinedTransform().inverted();
+        QRect transformed = region.boundingRect();
     \endcode
 */
@@ -7146 +7267 @@
 
     \fn QPoint QPainter::xFormDev(const QPolygon &polygon) const
-    \overload
-
-    Use  combinedMatrix() combined with QMatrix::inverted() instead.
+    \o
+
+    Use  combined::inverted() instead.
 
     \oldcode
@@ -7155 +7276 @@
     \newcode
         QPainter painter(this);
-        QPolygon transformed = polygon * painter.combinedMatrix().inverted();
+        QPolygon transformed = polygon * painter.combined().inverted();
     \endcode
 */
@@ -7174 +7295 @@
     \fn QPolygon QPainter::xFormDev(const QPolygon &polygon, int index, int count) const
     \overload
-
-    Use combinedMatrix() combined with QPolygon::mid() and QMatrix::inverted() instead.
+    \obsolete
+
+    Use combinedTransform() combined with QPolygon::mid() and QTransform::inverted() instead.
 
     \oldcode
@@ -7182 +7304 @@
     \newcode
         QPainter painter(this);
-        QPolygon transformed = polygon.mid(index, count) * painter.combinedMatrix().inverted();
+        QPolygon transformed = polygon.mid(index, count) * painter.combined().inverted();
     \endcode
 */
@@ -7377 +7499 @@
 void qt_painter_removePaintDevice(QPaintDevice *dev)
 {
-    QMutexLocker locker(globalRedirectionsMutex());
-    if(QPaintDeviceRedirectionList *redirections = globalRedirections()) {
+    QMutex *mutex = 0;
+    QT_TRY {
+        mutex = globalRedirectionsMutex();
+    } QT_CATCH(...) {
+        // ignore the missing mutex, since we could be called from
+        // a destructor, and destructors shall not throw
+    }
+    QMutexLocker locker(mutex);
+    QPaintDeviceRedirectionList *redirections = 0;
+    QT_TRY {
+        redirections = globalRedirections();
+    } QT_CATCH(...) {
+        // do nothing - code below is safe with redirections being 0.
+    }
+    if (redirections) {
         for (int i = 0; i < redirections->size(); ) {
             if(redirections->at(i) == dev || redirections->at(i).replacement == dev)
@@ -7428 +7563 @@
 
     Qt::LayoutDirection layout_direction;
-    if(option)
+    if (tf & Qt::TextForceLeftToRight)
+        layout_direction = Qt::LeftToRight;
+    else if (tf & Qt::TextForceRightToLeft)
+        layout_direction = Qt::RightToLeft;
+    else if (option)
         layout_direction = option->textDirection();
     else if (painter)
@@ -7445 +7584 @@
         tf |= Qt::TextDontPrint;
 
-    int maxUnderlines = 0;
+    int maxUnderlines = 0;
     int numUnderlines = 0;
-    int underlinePositionStack[32];
-    int *underlinePositions = underlinePositionStack;
+    QVarLengthArray<int, 32> underlinePositions(1);
 
     QFontMetricsF fm(fnt);
-
     QString text = str;
+
+
+
     // compatible behaviour to the old implementation. Replace
     // tabs by spaces
-    QChar *chr = text.data();
-    const QChar *end = chr + str.length();
-    bool has_tab = false;
-    while (chr != end) {
-        if (*chr == QLatin1Char('\r') || (singleline && *chr == QLatin1Char('\n'))) {
-            *chr = QLatin1Char(' ');
-        } else if (*chr == QLatin1Char('\n')) {
-            *chr = QChar::LineSeparator;
-        } else if (*chr == QLatin1Char('&')) {
+    int old_offset = offset;
+    for (; offset < text.length(); offset++) {
+        QChar chr = text.at(offset);
+        if (chr == QLatin1Char('\r') || (singleline && chr == QLatin1Char('\n'))) {
+            text[offset] = QLatin1Char(' ');
+        } else if (chr == QLatin1Char('\n')) {
+            text[offset] = QChar::LineSeparator;
+        } else if (chr == QLatin1Char('&')) {
             ++maxUnderlines;
-        } else if (*chr == QLatin1Char('\t')) {
-            has_tab = true;
+        } else if (chr == QLatin1Char('\t')) {
+            if (!expandtabs) {
+                text[offset] = QLatin1Char(' ');
+            } else if (!tabarraylen && !tabstops) {
+                tabstops = qRound(fm.width(QLatin1Char('x'))*8);
+            }
+        } else if (chr == QChar(ushort(0x9c))) {
+            // string with multiple length variants
+            hasMoreLengthVariants = true;
+            break;
         }
-        ++chr;
-    }
-    if (has_tab) {
-        if (!expandtabs) {
-            chr = text.data();
-            while (chr != end) {
-                if (*chr == QLatin1Char('\t'))
-                    *chr = QLatin1Char(' ');
-                ++chr;
-            }
-        } else if (!tabarraylen && !tabstops) {
-            tabstops = qRound(fm.width(QLatin1Char('x'))*8);
-        }
-    }
-
-    if (hidemnmemonic || showmnemonic) {
-        if (maxUnderlines > 32)
-            underlinePositions = new int[maxUnderlines];
-        QChar *cout = text.data();
+    }
+
+    int length = offset - old_offset;
+    if ((hidemnmemonic || showmnemonic) && maxUnderlines > 0) {
+        underlinePositions.resize(maxUnderlines + 1);
+
+        QChar *cout = text.data() + old_offset;
         QChar *cin = cout;
-        int l = str.length();
+        int l = ;
         while (l) {
             if (*cin == QLatin1Char('&')) {
                 ++cin;
+
                 --l;
                 if (!l)
                     break;
                 if (*cin != QLatin1Char('&') && !hidemnmemonic)
-                    underlinePositions[numUnderlines++] = cout - text.unicode();
+                    underlinePositions[numUnderlines++] = cout - text.;
             }
             *cout = *cin;
@@ -7503 +7639 @@
             --l;
         }
-        int newlen = cout - text.unicode();
-        if (newlen != text.length())
-            text.resize(newlen);
     }
 
@@ -7516 +7649 @@
     qreal width = 0;
 
-    QStackTextEngine engine(text, fnt);
+    QString finalText = text.mid(old_offset, length);
+    QStackTextEngine engine(finalText, fnt);
     if (option) {
         engine.option = *option;
     }
-
-
 
     engine.option.setTextDirection(layout_direction);
@@ -7536 +7668 @@
     QTextLayout textLayout(&engine);
     textLayout.setCacheEnabled(true);
-    textLayout.engine()->underlinePositions = underlinePositions;
-
-    if (text.isEmpty()) {
+    textLayout.engine()->underlinePositions = underlinePositions;
+
+    if (ext.isEmpty()) {
         height = fm.height();
         width = 0;
@@ -7564 +7696 @@
             height += l.height();
             width = qMax(width, l.naturalTextWidth());
-            if (!brect && height >= r.height())
+            if (!brect && height >= r.height())
                 break;
         }
@@ -7583 +7715 @@
                 const qreal scale = painter->transform().m22();
                 if (scale != 0)
-                    yoff = qRound(yoff * scale) / scale;
+                    yoff = yoff * scale) / scale;
             }
         }
@@ -7603 +7735 @@
     }
     QRectF bounds = QRectF(r.x() + xoff, r.y() + yoff, width, height);
+
+
+
+
+
     if (brect)
         *brect = bounds;
@@ -7629 +7766 @@
         }
     }
-
-    if (underlinePositions != underlinePositionStack)
-        delete [] underlinePositions;
 }
 
@@ -7664 +7798 @@
       clipOperation(s->clipOperation),
       renderHints(s->renderHints), clipInfo(s->clipInfo),
-      worldMatrix(s->worldMatrix), matrix(s->matrix), redirection_offset(s->redirection_offset),
+      worldMatrix(s->worldMatrix), matrix(s->matrix), redirection),
       wx(s->wx), wy(s->wy), ww(s->ww), wh(s->wh),
       vx(s->vx), vy(s->vy), vw(s->vw), vh(s->vh),
@@ -8086 +8220 @@
     \row \o QPaintEngine::DirtyCompositionMode \o compositionMode()
     \row \o QPaintEngine::DirtyFont \o font()
-    \row \o QPaintEngine::DirtyTransform \o matrix()
+    \row \o QPaintEngine::DirtyTransform \o ()
     \row \o QPaintEngine::DirtyClipEnabled \o isClipEnabled()
     \row \o QPaintEngine::DirtyPen \o pen()
@@ -8205 +8339 @@
 /*!
     \since 4.2
+
 
     Returns the matrix in the current paint engine
     state.
+
+
+
 
     This variable should only be used when the state() returns a
@@ -8389 +8527 @@
     the current matrix; otherwise it replaces the current matrix.
 
-    This function has been added for compatibility with setMatrix(),
-    but as with setMatrix() the preferred method of setting a
-    transformation on the painter is through setWorldTransform().
-
-    \sa transform()
+    \sa transform() setWorldTransform()
 */
 
@@ -8403 +8537 @@
 /*!
     Returns the world transformation matrix.
+
+
 */
 
@@ -8513 +8649 @@
     window/viewport and world transformation.
 
-    \sa setWorldMatrix(), setWindow(), setViewport()
+    \sa setWorld(), setWindow(), setViewport()
 */
 
@@ -8531 +8667 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 QT_END_NAMESPACE